ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Basis.toMatrix_reindex'
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁹ : CommRing R₂
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : Module R₂ M₂
e✝ : Basis ι R M
v✝ : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
b✝ : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝⁴ : Fintype ι'
inst✝³ : Finite κ
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq ι'
b : Basis ι R M
v : ι' → M
e : ι ≃ ι'
⊢ (b.reindex e).toMatrix v = (reindexAlgEquiv R R e) (b.toMatrix (v ∘ ⇑e))
state_after: case a
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁹ : CommRing R₂
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : Module R₂ M₂
e✝ : Basis ι R M
v✝ : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
b✝ : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝⁴ : Fintype ι'
inst✝³ : Finite κ
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq ι'
b : Basis ι R M
v : ι' → M
e : ι ≃ ι'
i✝ j✝ : ι'
⊢ (b.reindex e).toMatrix v i✝ j✝ = (reindexAlgEquiv R R e) (b.toMatrix (v ∘ ⇑e)) i✝ j✝
tactic: ext
state_before: case a
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁹ : CommRing R₂
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : Module R₂ M₂
e✝ : Basis ι R M
v✝ : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
b✝ : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝⁴ : Fintype ι'
inst✝³ : Finite κ
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : DecidableEq ι'
b : Basis ι R M
v : ι' → M
e : ι ≃ ι'
i✝ j✝ : ι'
⊢ (b.reindex e).toMatrix v i✝ j✝ = (reindexAlgEquiv R R e) (b.toMatrix (v ∘ ⇑e)) i✝ j✝
state_after: no goals
tactic: simp only [Basis.toMatrix_apply, Basis.repr_reindex, Matrix.reindexAlgEquiv_apply,
    Matrix.reindex_apply, Matrix.submatrix_apply, Function.comp_apply, e.apply_symm_apply,
    Finsupp.mapDomain_equiv_apply]
Theorem: equivShrink_symm_add
File: Mathlib/Logic/Small/Group.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Add α
inst✝ : Small.{u_2, u_1} α
x y : Shrink.{u_2, u_1} α
⊢ (equivShrink α).symm (x + y) = (equivShrink α).symm x + (equivShrink α).symm y
state_after: α : Type u_1
inst✝¹ : Add α
inst✝ : Small.{u_2, u_1} α
x y : Shrink.{u_2, u_1} α
⊢ (equivShrink α).symm ((equivShrink α).symm.symm ((equivShrink α).symm x + (equivShrink α).symm y)) =
    (equivShrink α).symm x + (equivShrink α).symm y
tactic: rw [Equiv.add_def]
state_before: α : Type u_1
inst✝¹ : Add α
inst✝ : Small.{u_2, u_1} α
x y : Shrink.{u_2, u_1} α
⊢ (equivShrink α).symm ((equivShrink α).symm.symm ((equivShrink α).symm x + (equivShrink α).symm y)) =
    (equivShrink α).symm x + (equivShrink α).symm y
state_after: no goals
tactic: simp
Theorem: exists_compact_iff_hasCompactSupport
File: Mathlib/Topology/Support.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace α'
inst✝³ : One β
inst✝² : One γ
inst✝¹ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
inst✝ : R1Space α
⊢ (∃ K, IsCompact K ∧ ∀ x ∉ K, f x = 1) ↔ HasCompactMulSupport f
state_after: no goals
tactic: simp_rw [← nmem_mulSupport, ← mem_compl_iff, ← subset_def, compl_subset_compl,
    hasCompactMulSupport_def, exists_isCompact_superset_iff]
Theorem: EReal.coe_ennreal_mul
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x : ℝ≥0
⊢ ↑(↑x * ⊤) = ↑↑x * ↑⊤
state_after: no goals
tactic: rw [mul_comm, coe_ennreal_top_mul, EReal.mul_comm, coe_ennreal_top]
state_before: x y : ℝ≥0
⊢ ↑(↑x * ↑y) = ↑↑x * ↑↑y
state_after: no goals
tactic: simp only [← ENNReal.coe_mul, coe_nnreal_eq_coe_real, NNReal.coe_mul, EReal.coe_mul]
Theorem: isOfFinOrder_iff_pow_eq_one
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
⊢ IsOfFinOrder x ↔ ∃ n, 0 < n ∧ x ^ n = 1
state_after: no goals
tactic: simp [IsOfFinOrder, mem_periodicPts, isPeriodicPt_mul_iff_pow_eq_one]
Theorem: RingTheory.Sequence.isRegular_cons_iff
File: Mathlib/RingTheory/Regular/RegularSequence.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : AddCommGroup M₃
inst✝⁴ : AddCommGroup M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
r : R
rs : List R
⊢ IsRegular M (r :: rs) ↔ IsSMulRegular M r ∧ IsRegular (QuotSMulTop r M) rs
state_after: no goals
tactic: rw [isRegular_iff, isRegular_iff, isWeaklyRegular_cons_iff M r rs,
    ne_eq, top_eq_ofList_cons_smul_iff, and_assoc]
Theorem: LinearMap.IsSymmetric.conj_eigenvalue_eq_self
File: Mathlib/Analysis/InnerProductSpace/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
μ : 𝕜
hμ : HasEigenvalue T μ
⊢ (starRingEnd 𝕜) μ = μ
state_after: case intro.intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
μ : 𝕜
hμ : HasEigenvalue T μ
v : E
hv₁ : v ∈ eigenspace T μ
hv₂ : v ≠ 0
⊢ (starRingEnd 𝕜) μ = μ
tactic: obtain ⟨v, hv₁, hv₂⟩ := hμ.exists_hasEigenvector
state_before: case intro.intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
μ : 𝕜
hμ : HasEigenvalue T μ
v : E
hv₁ : v ∈ eigenspace T μ
hv₂ : v ≠ 0
⊢ (starRingEnd 𝕜) μ = μ
state_after: case intro.intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
μ : 𝕜
hμ : HasEigenvalue T μ
v : E
hv₁ : T v = μ • v
hv₂ : v ≠ 0
⊢ (starRingEnd 𝕜) μ = μ
tactic: rw [mem_eigenspace_iff] at hv₁
state_before: case intro.intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
μ : 𝕜
hμ : HasEigenvalue T μ
v : E
hv₁ : T v = μ • v
hv₂ : v ≠ 0
⊢ (starRingEnd 𝕜) μ = μ
state_after: no goals
tactic: simpa [hv₂, inner_smul_left, inner_smul_right, hv₁] using hT v v
Theorem: LinearMap.ker_le_range_iff
File: Mathlib/LinearAlgebra/Quotient.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
R₂ : Type u_3
M₂ : Type u_4
R₃ : Type u_5
M₃ : Type u_6
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R₂
inst✝⁸ : Ring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
g : M₂ →ₛₗ[τ₂₃] M₃
⊢ ker g ≤ range f ↔ (range f).mkQ ∘ₗ (ker g).subtype = 0
state_after: no goals
tactic: rw [← range_le_ker_iff, Submodule.ker_mkQ, Submodule.range_subtype]
Theorem: AEMeasurable.ennreal_tsum
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
μ : Measure α
h : ∀ (i : ι), AEMeasurable (f i) μ
⊢ AEMeasurable (fun x => ∑' (i : ι), f i x) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
μ : Measure α
h : ∀ (i : ι), AEMeasurable (f i) μ
⊢ AEMeasurable (fun x => ⨆ s, ∑ i ∈ s, f i x) μ
tactic: simp_rw [ENNReal.tsum_eq_iSup_sum]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
μ : Measure α
h : ∀ (i : ι), AEMeasurable (f i) μ
⊢ AEMeasurable (fun x => ⨆ s, ∑ i ∈ s, f i x) μ
state_after: case hf
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
μ : Measure α
h : ∀ (i : ι), AEMeasurable (f i) μ
⊢ ∀ (i : Finset ι), AEMeasurable (fun b => ∑ i ∈ i, f i b) μ
tactic: apply aemeasurable_iSup
state_before: case hf
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
μ : Measure α
h : ∀ (i : ι), AEMeasurable (f i) μ
⊢ ∀ (i : Finset ι), AEMeasurable (fun b => ∑ i ∈ i, f i b) μ
state_after: no goals
tactic: exact fun s => Finset.aemeasurable_sum s fun i _ => h i
Theorem: Multiset.lcm_ndinsert
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ (ndinsert a s).lcm = GCDMonoid.lcm a s.lcm
state_after: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ ∀ (a_1 : α), a_1 ∈ ndinsert a s ↔ a_1 ∈ a ::ₘ s
tactic: rw [← lcm_dedup, dedup_ext.2, lcm_dedup, lcm_cons]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ ∀ (a_1 : α), a_1 ∈ ndinsert a s ↔ a_1 ∈ a ::ₘ s
state_after: no goals
tactic: simp
Theorem: MeasureTheory.exists_nat_measurableEquiv_range_coe_fin_of_finite
File: Mathlib/MeasureTheory/Constructions/Polish/EmbeddingReal.lean

Proof steps:
state_before: α : Type u_1
inst✝² : MeasurableSpace α
inst✝¹ : StandardBorelSpace α
inst✝ : Finite α
⊢ ∃ n, Nonempty (α ≃ᵐ ↑(range fun x => ↑↑x))
state_after: case intro.intro
α : Type u_1
inst✝² : MeasurableSpace α
inst✝¹ : StandardBorelSpace α
inst✝ : Finite α
n : ℕ
n_equiv : α ≃ Fin n
⊢ ∃ n, Nonempty (α ≃ᵐ ↑(range fun x => ↑↑x))
tactic: obtain ⟨n, ⟨n_equiv⟩⟩ := Finite.exists_equiv_fin α
state_before: case intro.intro
α : Type u_1
inst✝² : MeasurableSpace α
inst✝¹ : StandardBorelSpace α
inst✝ : Finite α
n : ℕ
n_equiv : α ≃ Fin n
⊢ ∃ n, Nonempty (α ≃ᵐ ↑(range fun x => ↑↑x))
state_after: case intro.intro
α : Type u_1
inst✝² : MeasurableSpace α
inst✝¹ : StandardBorelSpace α
inst✝ : Finite α
n : ℕ
n_equiv : α ≃ Fin n
⊢ Fin n ≃ ↑(range fun x => ↑↑x)
tactic: refine ⟨n, ⟨PolishSpace.Equiv.measurableEquiv (n_equiv.trans ?_)⟩⟩
state_before: case intro.intro
α : Type u_1
inst✝² : MeasurableSpace α
inst✝¹ : StandardBorelSpace α
inst✝ : Finite α
n : ℕ
n_equiv : α ≃ Fin n
⊢ Fin n ≃ ↑(range fun x => ↑↑x)
state_after: no goals
tactic: exact Equiv.ofInjective _ (Nat.cast_injective.comp Fin.val_injective)
Theorem: Matrix.cons_vecMul
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : NonUnitalNonAssocSemiring α
x : α
v : Fin n → α
B : Fin n.succ → o' → α
⊢ vecCons x v ᵥ* of B = x • vecHead B + v ᵥ* of (vecTail B)
state_after: case h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : NonUnitalNonAssocSemiring α
x : α
v : Fin n → α
B : Fin n.succ → o' → α
i : o'
⊢ (vecCons x v ᵥ* of B) i = (x • vecHead B + v ᵥ* of (vecTail B)) i
tactic: ext i
state_before: case h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : NonUnitalNonAssocSemiring α
x : α
v : Fin n → α
B : Fin n.succ → o' → α
i : o'
⊢ (vecCons x v ᵥ* of B) i = (x • vecHead B + v ᵥ* of (vecTail B)) i
state_after: no goals
tactic: simp [vecMul]
Theorem: QuadraticMap.Isometry.snd_apply
File: Mathlib/LinearAlgebra/QuadraticForm/Prod.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
P : Type u_7
Mᵢ : ι → Type u_8
Nᵢ : ι → Type u_9
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M₁
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid N₁
inst✝⁶ : AddCommMonoid N₂
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R P
Q₂ : QuadraticMap R M₂ P
m₁ : M₁ × M₂
⊢ Q₂ ((LinearMap.snd R M₁ M₂).toFun m₁) = (prod 0 Q₂) m₁
state_after: no goals
tactic: simp
Theorem: OnePoint.comap_coe_nhds_infty
File: Mathlib/Topology/Compactification/OnePoint.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ comap some (𝓝 ∞) = coclosedCompact X
state_after: no goals
tactic: simp [nhds_infty_eq, comap_sup, comap_map coe_injective]
Theorem: Matroid.Base.rkPos_of_nonempty
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B B₁ B₂ : Set α
hB : M.Base B
h : B.Nonempty
⊢ M.RkPos
state_after: α : Type u_1
M : Matroid α
B B₁ B₂ : Set α
hB : M.Base B
h : B.Nonempty
⊢ ¬M.Base ∅
tactic: rw [rkPos_iff_empty_not_base]
state_before: α : Type u_1
M : Matroid α
B B₁ B₂ : Set α
hB : M.Base B
h : B.Nonempty
⊢ ¬M.Base ∅
state_after: α : Type u_1
M : Matroid α
B B₁ B₂ : Set α
hB : M.Base B
h : B.Nonempty
he : M.Base ∅
⊢ False
tactic: intro he
state_before: α : Type u_1
M : Matroid α
B B₁ B₂ : Set α
hB : M.Base B
h : B.Nonempty
he : M.Base ∅
⊢ False
state_after: α : Type u_1
M : Matroid α
B₁ B₂ : Set α
he hB : M.Base ∅
h : ∅.Nonempty
⊢ False
tactic: obtain rfl := he.eq_of_subset_base hB (empty_subset B)
state_before: α : Type u_1
M : Matroid α
B₁ B₂ : Set α
he hB : M.Base ∅
h : ∅.Nonempty
⊢ False
state_after: no goals
tactic: simp at h
Theorem: Complex.cpow_ofReal_im
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x : ℂ
y : ℝ
⊢ (x ^ ↑y).im = abs x ^ y * Real.sin (x.arg * y)
state_after: x : ℂ
y : ℝ
⊢ (↑(abs x ^ y) * (↑(Real.cos (x.arg * y)) + ↑(Real.sin (x.arg * y)) * I)).im = abs x ^ y * Real.sin (x.arg * y)
tactic: rw [cpow_ofReal]
state_before: x : ℂ
y : ℝ
⊢ (↑(abs x ^ y) * (↑(Real.cos (x.arg * y)) + ↑(Real.sin (x.arg * y)) * I)).im = abs x ^ y * Real.sin (x.arg * y)
state_after: x : ℂ
y z : ℝ
⊢ (↑(abs x ^ y) * (↑(Real.cos z) + ↑(Real.sin z) * I)).im = abs x ^ y * Real.sin z
tactic: generalize arg x * y = z
state_before: x : ℂ
y z : ℝ
⊢ (↑(abs x ^ y) * (↑(Real.cos z) + ↑(Real.sin z) * I)).im = abs x ^ y * Real.sin z
state_after: no goals
tactic: simp [Real.sin]
Theorem: Ordinal.add_mul_succ
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: a b c : Ordinal.{u_1}
ba : b + a = a
⊢ (a + b) * succ c = a * succ c + b
state_after: no goals
tactic: induction c using limitRecOn with
  | H₁ => simp only [succ_zero, mul_one]
  | H₂ c IH =>
    rw [mul_succ, IH, ← add_assoc, add_assoc _ b, ba, ← mul_succ]
  | H₃ c l IH =>
    -- Porting note: Unused.
    -- have := add_mul_limit_aux ba l IH
    rw [mul_succ, add_mul_limit_aux ba l IH, mul_succ, add_assoc]
Theorem: Finset.univ_nonempty_iff
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Fintype α
s t : Finset α
⊢ univ.Nonempty ↔ Nonempty α
state_after: no goals
tactic: rw [← coe_nonempty, coe_univ, Set.nonempty_iff_univ_nonempty]
Theorem: Submonoid.powers_le
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

Proof steps:
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : Monoid M
a n : M
P : Submonoid M
⊢ powers n ≤ P ↔ n ∈ P
state_after: no goals
tactic: simp [powers_eq_closure]
Theorem: Polynomial.smeval_commute
File: Mathlib/Algebra/Polynomial/Smeval.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : Semiring R
p q : R[X]
S : Type u_2
inst✝³ : Semiring S
inst✝² : Module R S
inst✝¹ : IsScalarTower R S S
inst✝ : SMulCommClass R S S
x y : S
hc : Commute x y
⊢ Commute (p.smeval x) (q.smeval y)
state_after: no goals
tactic: induction p using Polynomial.induction_on' with
  | h_add r s hr hs => exact (smeval_add R r s x) ▸ Commute.add_left hr hs
  | h_monomial n a =>
    simp only [smeval_monomial]
    refine Commute.smul_left ?_ a
    induction n with
    | zero => simp only [npow_zero, Commute.one_left]
    | succ n ih =>
      refine (commute_iff_eq (x ^ (n + 1)) (q.smeval y)).mpr ?_
      rw [commute_iff_eq (x ^ n) (q.smeval y)] at ih
      have hxq : x * q.smeval y = q.smeval y * x := by
        refine (commute_iff_eq x (q.smeval y)).mp ?_
        exact Commute.symm (smeval_commute_left R q (Commute.symm hc))
      rw [pow_succ, ← mul_assoc, ← ih, mul_assoc, hxq, mul_assoc]
Theorem: Linarith.mul_nonpos
File: Mathlib/Tactic/Linarith/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedRing α
a b : α
ha : a ≤ 0
hb : 0 < b
this : -b * a ≥ 0
⊢ b * a ≤ 0
state_after: no goals
tactic: simpa
Theorem: Ordinal.lift_type_lt
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
⊢ lift.{max v w, u} (type r) < lift.{max u w, v} (type s) ↔ Nonempty (r ≺i s)
state_after: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
this : IsWellOrder (ULift.{max v w, u} α) (⇑Equiv.ulift ⁻¹'o r)
⊢ lift.{max v w, u} (type r) < lift.{max u w, v} (type s) ↔ Nonempty (r ≺i s)
tactic: haveI := @RelEmbedding.isWellOrder _ _ (@Equiv.ulift.{max v w} α ⁻¹'o r) r
    (RelIso.preimage Equiv.ulift.{max v w} r) _
state_before: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
this : IsWellOrder (ULift.{max v w, u} α) (⇑Equiv.ulift ⁻¹'o r)
⊢ lift.{max v w, u} (type r) < lift.{max u w, v} (type s) ↔ Nonempty (r ≺i s)
state_after: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
this✝ : IsWellOrder (ULift.{max v w, u} α) (⇑Equiv.ulift ⁻¹'o r)
this : IsWellOrder (ULift.{max u w, v} β) (⇑Equiv.ulift ⁻¹'o s)
⊢ lift.{max v w, u} (type r) < lift.{max u w, v} (type s) ↔ Nonempty (r ≺i s)
tactic: haveI := @RelEmbedding.isWellOrder _ _ (@Equiv.ulift.{max u w} β ⁻¹'o s) s
    (RelIso.preimage Equiv.ulift.{max u w} s) _
state_before: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝¹ : IsWellOrder α r
inst✝ : IsWellOrder β s
this✝ : IsWellOrder (ULift.{max v w, u} α) (⇑Equiv.ulift ⁻¹'o r)
this : IsWellOrder (ULift.{max u w, v} β) (⇑Equiv.ulift ⁻¹'o s)
⊢ lift.{max v w, u} (type r) < lift.{max u w, v} (type s) ↔ Nonempty (r ≺i s)
state_after: no goals
tactic: exact ⟨fun ⟨f⟩ =>
    ⟨(f.equivLT (RelIso.preimage Equiv.ulift r).symm).ltLe
        (InitialSeg.ofIso (RelIso.preimage Equiv.ulift s))⟩,
    fun ⟨f⟩ =>
    ⟨(f.equivLT (RelIso.preimage Equiv.ulift r)).ltLe
        (InitialSeg.ofIso (RelIso.preimage Equiv.ulift s).symm)⟩⟩
Theorem: direction_affineSpan
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
⊢ (affineSpan k s).direction = vectorSpan k s
state_after: case a
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
⊢ (affineSpan k s).direction ≤ vectorSpan k s

case a
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
⊢ vectorSpan k s ≤ (affineSpan k s).direction
tactic: apply le_antisymm
Theorem: Ordnode.emem_iff_mem_toList
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
x : α
t : Ordnode α
⊢ Emem x t ↔ x ∈ t.toList
state_after: α : Type u_1
x : α
t : Ordnode α
⊢ Any (Eq x) t ↔ x ∈ t.toList
tactic: unfold Emem
state_before: α : Type u_1
x : α
t : Ordnode α
⊢ Any (Eq x) t ↔ x ∈ t.toList
state_after: no goals
tactic: induction t <;> simp [Any, *, or_assoc]
Theorem: Polynomial.natDegree_mul'
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff * q.leadingCoeff ≠ 0
h₁ : p.leadingCoeff = 0
⊢ p.leadingCoeff * q.leadingCoeff = 0
state_after: no goals
tactic: rw [h₁, zero_mul]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff * q.leadingCoeff ≠ 0
hp : p ≠ 0
h₁ : q.leadingCoeff = 0
⊢ p.leadingCoeff * q.leadingCoeff = 0
state_after: no goals
tactic: rw [h₁, mul_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : p.leadingCoeff * q.leadingCoeff ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ (p * q).degree = ↑(p.natDegree + q.natDegree)
state_after: no goals
tactic: rw [degree_mul' h, Nat.cast_add, degree_eq_natDegree hp, degree_eq_natDegree hq]
Theorem: Cardinal.ofENat_le_nat
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: m : ℕ∞
n : ℕ
⊢ ↑m ≤ ↑n ↔ m ≤ ↑n
state_after: no goals
tactic: norm_cast
Theorem: Comon_.counit_comul_hom
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
Z : C
f : M.X ⟶ Z
⊢ M.comul ≫ (M.counit ⊗ f) = f ≫ (λ_ Z).inv
state_after: no goals
tactic: rw [leftUnitor_inv_naturality, tensorHom_def, counit_comul_assoc]
Theorem: Subgroup.zpowers_le
File: Mathlib/Algebra/Group/Subgroup/ZPowers.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
A : Type u_2
inst✝¹ : AddGroup A
N : Type u_3
inst✝ : Group N
s : Set G
g✝ g : G
H : Subgroup G
⊢ zpowers g ≤ H ↔ g ∈ H
state_after: no goals
tactic: rw [zpowers_eq_closure, closure_le, Set.singleton_subset_iff, SetLike.mem_coe]
Theorem: UniqueFactorizationMonoid.factors_pos
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
⊢ 0 < factors x ↔ ¬IsUnit x
state_after: case mp
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
⊢ 0 < factors x → ¬IsUnit x

case mpr
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
⊢ ¬IsUnit x → 0 < factors x
tactic: constructor
Theorem: Monoid.Coprod.snd_comp_toProd
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
⊢ (MonoidHom.snd M N).comp toProd = snd
state_after: no goals
tactic: rw [← fst_prod_snd, MonoidHom.snd_comp_prod]