ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MulAction.mem_stabilizer_finset_iff_smul_finset_subset
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
s : Finset α
⊢ a ∈ stabilizer G s ↔ a • s ⊆ s
state_after: no goals
tactic: rw [mem_stabilizer_iff, Finset.subset_iff_eq_of_card_le (Finset.card_smul_finset _ _).ge]
Theorem: Finsupp.cons_ne_zero_of_left
File: Mathlib/Data/Finsupp/Fin.lean

Proof steps:
state_before: n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
h : y ≠ 0
⊢ cons y s ≠ 0
state_after: n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
c : cons y s = 0
⊢ y = 0
tactic: contrapose! h with c
state_before: n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
c : cons y s = 0
⊢ y = 0
state_after: no goals
tactic: rw [← cons_zero y s, c, Finsupp.coe_zero, Pi.zero_apply]
Theorem: Homeomorph.piSplitAt_symm_apply
File: Mathlib/Topology/Homeomorph.lean

Proof steps:
state_before: X : Type u_1
Y✝ : Type u_2
Z : Type u_3
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y✝
inst✝⁴ : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝³ : TopologicalSpace X'
inst✝² : TopologicalSpace Y'
ι : Type u_6
inst✝¹ : DecidableEq ι
i : ι
Y : ι → Type u_7
inst✝ : (j : ι) → TopologicalSpace (Y j)
j : ι
⊢ Continuous fun a => (Equiv.piSplitAt i Y).invFun a j
state_after: X : Type u_1
Y✝ : Type u_2
Z : Type u_3
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y✝
inst✝⁴ : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝³ : TopologicalSpace X'
inst✝² : TopologicalSpace Y'
ι : Type u_6
inst✝¹ : DecidableEq ι
i : ι
Y : ι → Type u_7
inst✝ : (j : ι) → TopologicalSpace (Y j)
j : ι
⊢ Continuous fun a => if h : j = i then ⋯ ▸ a.1 else a.2 ⟨j, h⟩
tactic: dsimp only [Equiv.piSplitAt]
state_before: X : Type u_1
Y✝ : Type u_2
Z : Type u_3
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y✝
inst✝⁴ : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝³ : TopologicalSpace X'
inst✝² : TopologicalSpace Y'
ι : Type u_6
inst✝¹ : DecidableEq ι
i : ι
Y : ι → Type u_7
inst✝ : (j : ι) → TopologicalSpace (Y j)
j : ι
⊢ Continuous fun a => if h : j = i then ⋯ ▸ a.1 else a.2 ⟨j, h⟩
state_after: case pos
X : Type u_1
Y✝ : Type u_2
Z : Type u_3
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y✝
inst✝⁴ : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝³ : TopologicalSpace X'
inst✝² : TopologicalSpace Y'
ι : Type u_6
inst✝¹ : DecidableEq ι
i : ι
Y : ι → Type u_7
inst✝ : (j : ι) → TopologicalSpace (Y j)
j : ι
h : j = i
⊢ Continuous fun a => ⋯ ▸ a.1

case neg
X : Type u_1
Y✝ : Type u_2
Z : Type u_3
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y✝
inst✝⁴ : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝³ : TopologicalSpace X'
inst✝² : TopologicalSpace Y'
ι : Type u_6
inst✝¹ : DecidableEq ι
i : ι
Y : ι → Type u_7
inst✝ : (j : ι) → TopologicalSpace (Y j)
j : ι
h : ¬j = i
⊢ Continuous fun a => a.2 ⟨j, h⟩
tactic: split_ifs with h
Theorem: Cardinal.mul_le_max_of_aleph0_le_right
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: a b : Cardinal.{u_1}
h : ℵ₀ ≤ b
⊢ a * b ≤ max a b
state_after: no goals
tactic: simpa only [mul_comm b, max_comm b] using mul_le_max_of_aleph0_le_left h
Theorem: NNReal.rpow_one_div_le_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: w x✝ y✝ z✝ : ℝ
x y : ℝ≥0
z : ℝ
hz : 0 < z
⊢ x ^ (1 / z) ≤ y ↔ x ≤ y ^ z
state_after: no goals
tactic: rw [← rpow_le_rpow_iff hz, rpow_self_rpow_inv hz.ne']
Theorem: continuous_norm'
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
⊢ Continuous fun a => ‖a‖
state_after: no goals
tactic: simpa using continuous_id.dist (continuous_const : Continuous fun _a => (1 : E))
Theorem: lt_mul_inv_iff_lt
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ 1 < a * b⁻¹ ↔ b < a
state_after: no goals
tactic: rw [← mul_lt_mul_iff_right b, one_mul, inv_mul_cancel_right]
Theorem: supClosure_univ
File: Mathlib/Order/SupClosed.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
s t : Set α
a b : α
⊢ supClosure Set.univ = Set.univ
state_after: no goals
tactic: simp
Theorem: zmultiples_eq_top_of_prime_card
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
x✝ : Fintype G
p : ℕ
hp : Fact (Nat.Prime p)
h : Fintype.card G = p
g : G
hg : g ≠ 1
⊢ zpowers g = ⊤
state_after: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
x✝ : Fintype G
g : G
hg : g ≠ 1
hp : Fact (Nat.Prime (Fintype.card G))
⊢ zpowers g = ⊤
tactic: subst h
state_before: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
x✝ : Fintype G
g : G
hg : g ≠ 1
hp : Fact (Nat.Prime (Fintype.card G))
⊢ zpowers g = ⊤
state_after: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
x✝ : Fintype G
g : G
hg : g ≠ 1
hp : Fact (Nat.Prime (Fintype.card G))
this : zpowers g = ⊥ ∨ zpowers g = ⊤
⊢ zpowers g = ⊤
tactic: have := (zpowers g).eq_bot_or_eq_top_of_prime_card
state_before: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
x✝ : Fintype G
g : G
hg : g ≠ 1
hp : Fact (Nat.Prime (Fintype.card G))
this : zpowers g = ⊥ ∨ zpowers g = ⊤
⊢ zpowers g = ⊤
state_after: no goals
tactic: rwa [zpowers_eq_bot, or_iff_right hg] at this
Theorem: neg_add_lt_iff_lt_add'
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ c⁻¹ * a < b ↔ a < b * c
state_after: no goals
tactic: rw [inv_mul_lt_iff_lt_mul, mul_comm]
Theorem: symmDiff_sdiff
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ∆ b \ c = a \ (b ⊔ c) ⊔ b \ (a ⊔ c)
state_after: no goals
tactic: rw [symmDiff, sup_sdiff_distrib, sdiff_sdiff_left, sdiff_sdiff_left]
Theorem: MeasureTheory.IsFundamentalDomain.measurePreserving_quotient_mk
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁷ : Group G
inst✝⁶ : MulAction G α
inst✝⁵ : MeasurableSpace α
ν : Measure α
inst✝⁴ : Countable G
inst✝³ : MeasurableSpace G
inst✝² : SMulInvariantMeasure G α ν
inst✝¹ : MeasurableSMul G α
𝓕 : Set α
h𝓕 : IsFundamentalDomain G 𝓕 ν
μ : Measure (Quotient α_mod_G)
inst✝ : QuotientMeasureEqMeasurePreimage ν μ
⊢ Measure.map (Quotient.mk α_mod_G) (ν.restrict 𝓕) = μ
state_after: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁷ : Group G
inst✝⁶ : MulAction G α
inst✝⁵ : MeasurableSpace α
ν : Measure α
inst✝⁴ : Countable G
inst✝³ : MeasurableSpace G
inst✝² : SMulInvariantMeasure G α ν
inst✝¹ : MeasurableSMul G α
𝓕 : Set α
h𝓕 : IsFundamentalDomain G 𝓕 ν
μ : Measure (Quotient α_mod_G)
inst✝ : QuotientMeasureEqMeasurePreimage ν μ
this : HasFundamentalDomain G α ν
⊢ Measure.map (Quotient.mk α_mod_G) (ν.restrict 𝓕) = μ
tactic: haveI : HasFundamentalDomain G α ν := ⟨𝓕, h𝓕⟩
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁷ : Group G
inst✝⁶ : MulAction G α
inst✝⁵ : MeasurableSpace α
ν : Measure α
inst✝⁴ : Countable G
inst✝³ : MeasurableSpace G
inst✝² : SMulInvariantMeasure G α ν
inst✝¹ : MeasurableSMul G α
𝓕 : Set α
h𝓕 : IsFundamentalDomain G 𝓕 ν
μ : Measure (Quotient α_mod_G)
inst✝ : QuotientMeasureEqMeasurePreimage ν μ
this : HasFundamentalDomain G α ν
⊢ Measure.map (Quotient.mk α_mod_G) (ν.restrict 𝓕) = μ
state_after: no goals
tactic: rw [h𝓕.projection_respects_measure (μ := μ)]
Theorem: CategoryTheory.MonoidalCategory.comp_whiskerRight
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
W X Y : C
f : W ⟶ X
g : X ⟶ Y
Z : C
⊢ (f ≫ g) ▷ Z = f ▷ Z ≫ g ▷ Z
state_after: no goals
tactic: simp only [← tensorHom_id, ← tensor_comp, id_comp]
Theorem: Cardinal.ord_isLimit
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: c : Cardinal.{u_1}
co : ℵ₀ ≤ c
⊢ c.ord.IsLimit
state_after: case refine_1
c : Cardinal.{u_1}
co : ℵ₀ ≤ c
h : c.ord = 0
⊢ ℵ₀ = 0

case refine_2
c : Cardinal.{u_1}
co : ℵ₀ ≤ c
a : Ordinal.{u_1}
h : c.ord ≤ succ a
⊢ c.ord ≤ a
tactic: refine ⟨fun h => aleph0_ne_zero ?_, fun a => lt_imp_lt_of_le_imp_le fun h => ?_⟩
Theorem: ProbabilityTheory.integrable_compProd_iff
File: Mathlib/Probability/Kernel/IntegralCompProd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝² : NormedAddCommGroup E
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → E
hf : AEStronglyMeasurable f ((κ ⊗ₖ η) a)
⊢ Integrable f ((κ ⊗ₖ η) a) ↔
    (∀ᵐ (x : β) ∂κ a, Integrable (fun y => f (x, y)) (η (a, x))) ∧
      Integrable (fun x => ∫ (y : γ), ‖f (x, y)‖ ∂η (a, x)) (κ a)
state_after: no goals
tactic: simp only [Integrable, hasFiniteIntegral_compProd_iff' hf, hf.norm.integral_kernel_compProd,
    hf, hf.compProd_mk_left, eventually_and, true_and_iff]
Theorem: Homeomorph.toPartialHomeomorphOfImageEq_symm_apply
File: Mathlib/Topology/PartialHomeomorph.lean

Proof steps:
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e✝ : PartialHomeomorph X Y
e : X ≃ₜ Y
s : Set X
hs : IsOpen s
t : Set Y
h : ⇑e '' s = t
⊢ IsOpen (e.toPartialEquivOfImageEq s t h).target
state_after: no goals
tactic: simpa [← h]
Theorem: gaussSum_mulShift_of_isPrimitive
File: Mathlib/NumberTheory/DirichletCharacter/GaussSum.lean

Proof steps:
state_before: N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
hχ : χ.IsPrimitive
a : ZMod N
⊢ gaussSum χ (e.mulShift a) = χ⁻¹ a * gaussSum χ e
state_after: case pos
N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
hχ : χ.IsPrimitive
a : ZMod N
ha : IsUnit a
⊢ gaussSum χ (e.mulShift a) = χ⁻¹ a * gaussSum χ e

case neg
N : ℕ
inst✝² : NeZero N
R : Type u_1
inst✝¹ : CommRing R
e : AddChar (ZMod N) R
inst✝ : IsDomain R
χ : DirichletCharacter R N
hχ : χ.IsPrimitive
a : ZMod N
ha : ¬IsUnit a
⊢ gaussSum χ (e.mulShift a) = χ⁻¹ a * gaussSum χ e
tactic: by_cases ha : IsUnit a
Theorem: SetTheory.PGame.neg_fuzzy_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
⊢ -x ‖ -y ↔ x ‖ y
state_after: no goals
tactic: rw [Fuzzy, Fuzzy, neg_lf_neg_iff, neg_lf_neg_iff, and_comm]
Theorem: CategoryTheory.ShortComplex.exact_iff_of_epi_of_isIso_of_mono
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{?u.11351, u_2} D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
inst✝² : Epi φ.τ₁
inst✝¹ : IsIso φ.τ₂
inst✝ : Mono φ.τ₃
⊢ S₁.Exact ↔ S₂.Exact
state_after: case mp
C : Type u_1
D : Type u_2
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{?u.11351, u_2} D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
inst✝² : Epi φ.τ₁
inst✝¹ : IsIso φ.τ₂
inst✝ : Mono φ.τ₃
⊢ S₁.Exact → S₂.Exact

case mpr
C : Type u_1
D : Type u_2
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{?u.11351, u_2} D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
inst✝² : Epi φ.τ₁
inst✝¹ : IsIso φ.τ₂
inst✝ : Mono φ.τ₃
⊢ S₂.Exact → S₁.Exact
tactic: constructor
Theorem: one_lt_ack_succ_left
File: Mathlib/Computability/Ackermann.lean

Proof steps:
state_before: n : ℕ
⊢ 1 < ack (0 + 1) n
state_after: no goals
tactic: simp
state_before: m : ℕ
⊢ 1 < ack (m + 1 + 1) 0
state_after: m : ℕ
⊢ 1 < ack (m + 1) 1
tactic: rw [ack_succ_zero]
state_before: m : ℕ
⊢ 1 < ack (m + 1) 1
state_after: no goals
tactic: apply one_lt_ack_succ_left
state_before: m n : ℕ
⊢ 1 < ack (m + 1 + 1) (n + 1)
state_after: m n : ℕ
⊢ 1 < ack (m + 1) (ack (m + 1 + 1) n)
tactic: rw [ack_succ_succ]
state_before: m n : ℕ
⊢ 1 < ack (m + 1) (ack (m + 1 + 1) n)
state_after: no goals
tactic: apply one_lt_ack_succ_left
Theorem: infClosure_univ
File: Mathlib/Order/SupClosed.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
s t : Set α
a b : α
⊢ infClosure Set.univ = Set.univ
state_after: no goals
tactic: simp
Theorem: AffineSubspace.mem_direction_iff_eq_vsub_right
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 : AffineSubspace k P
p : P
hp : p ∈ s
v : V
⊢ v ∈ s.direction ↔ ∃ p2 ∈ s, v = p2 -ᵥ p
state_after: 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 : AffineSubspace k P
p : P
hp : p ∈ s
v : V
⊢ v ∈ (fun x => x -ᵥ p) '' ↑s ↔ ∃ p2 ∈ s, v = p2 -ᵥ p
tactic: rw [← SetLike.mem_coe, coe_direction_eq_vsub_set_right hp]
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 : AffineSubspace k P
p : P
hp : p ∈ s
v : V
⊢ v ∈ (fun x => x -ᵥ p) '' ↑s ↔ ∃ p2 ∈ s, v = p2 -ᵥ p
state_after: no goals
tactic: exact ⟨fun ⟨p2, hp2, hv⟩ => ⟨p2, hp2, hv.symm⟩, fun ⟨p2, hp2, hv⟩ => ⟨p2, hp2, hv.symm⟩⟩
Theorem: Cardinal.ciSup_mul_ciSup
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: ι : Type u
ι' : Type w
f : ι → Cardinal.{v}
g : ι' → Cardinal.{v}
⊢ (⨆ i, f i) * ⨆ j, g j = ⨆ i, ⨆ j, f i * g j
state_after: no goals
tactic: simp_rw [Cardinal.ciSup_mul f, Cardinal.mul_ciSup g]
Theorem: Finset.affineCombination_affineCombinationLineMapWeights
File: Mathlib/LinearAlgebra/AffineSpace/Combination.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
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
inst✝ : DecidableEq ι
p : ι → P
i j : ι
hi : i ∈ s
hj : j ∈ s
c : k
⊢ (affineCombination k s p) (affineCombinationLineMapWeights i j c) = (AffineMap.lineMap (p i) (p j)) c
state_after: no goals
tactic: rw [affineCombinationLineMapWeights, ← weightedVSub_vadd_affineCombination,
    weightedVSub_const_smul, s.affineCombination_affineCombinationSingleWeights k p hi,
    s.weightedVSub_weightedVSubVSubWeights k p hj hi, AffineMap.lineMap_apply]
Theorem: Real.arsinh_zero
File: Mathlib/Analysis/SpecialFunctions/Arsinh.lean

Proof steps:
state_before: x y : ℝ
⊢ arsinh 0 = 0
state_after: no goals
tactic: simp [arsinh]
Theorem: TensorPower.list_prod_gradedMonoid_mk_single
File: Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
x : Fin n → M
⊢ (List.map (fun a => GradedMonoid.mk 1 ((PiTensorProduct.tprod R) fun x_1 => x a)) (List.finRange n)).prod =
    GradedMonoid.mk n ((PiTensorProduct.tprod R) x)
state_after: case refine_1
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
⊢ (List.map (fun a => GradedMonoid.mk 1 ((PiTensorProduct.tprod R) fun x => a.elim0)) (List.finRange 0)).prod =
    GradedMonoid.mk 0 ((PiTensorProduct.tprod R) Fin.elim0)

case refine_2
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n : ℕ
⊢ ∀ {n : ℕ} (x₀ : M) (x : Fin n → M),
    (List.map (fun a => GradedMonoid.mk 1 ((PiTensorProduct.tprod R) fun x_1 => x a)) (List.finRange n)).prod =
        GradedMonoid.mk n ((PiTensorProduct.tprod R) x) →
      (List.map (fun a => GradedMonoid.mk 1 ((PiTensorProduct.tprod R) fun x_1 => Fin.cons x₀ x a))
            (List.finRange (n + 1))).prod =
        GradedMonoid.mk (n + 1) ((PiTensorProduct.tprod R) (Fin.cons x₀ x))
tactic: refine Fin.consInduction ?_ ?_ x <;> clear x
Theorem: Finset.map_erase
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α ↪ β
s : Finset α
a : α
⊢ map f (s.erase a) = (map f s).erase (f a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α ↪ β
s : Finset α
a : α
⊢ image (⇑f) (s.erase a) = (image (⇑f) s).erase (f a)
tactic: simp_rw [map_eq_image]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α ↪ β
s : Finset α
a : α
⊢ image (⇑f) (s.erase a) = (image (⇑f) s).erase (f a)
state_after: no goals
tactic: exact s.image_erase f.2 a
Theorem: Real.Angle.eq_iff_abs_toReal_eq_of_sign_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ ψ : Angle
h : θ.sign = ψ.sign
⊢ θ = ψ ↔ |θ.toReal| = |ψ.toReal|
state_after: no goals
tactic: simpa [h] using @eq_iff_sign_eq_and_abs_toReal_eq θ ψ
Theorem: SignType.nonneg_iff_ne_neg_one
File: Mathlib/Data/Sign.lean

Proof steps:
state_before: a : SignType
⊢ 0 ≤ a ↔ a ≠ -1
state_after: no goals
tactic: cases a <;> decide
Theorem: Batteries.BinomialHeap.Imp.Heap.realSize_merge
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean

Proof steps:
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
⊢ (merge le s₁ s₂).realSize = s₁.realSize + s₂.realSize
state_after: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
⊢ (match s₁, s₂ with
      | nil, h => h
      | h, nil => h
      | s₁@h:(cons r₁ a₁ n₁ t₁), s₂@h_1:(cons r₂ a₂ n₂ t₂) =>
        if r₁ < r₂ then cons r₁ a₁ n₁ (merge le t₁ s₂)
        else
          if r₂ < r₁ then cons r₂ a₂ n₂ (merge le s₁ t₂)
          else
            match combine le a₁ a₂ n₁ n₂ with
            | (a, n) =>
              let r := r₁ + 1;
              if t₁.rankGT r then if t₂.rankGT r then cons r a n (merge le t₁ t₂) else merge le (cons r a n t₁) t₂
              else if t₂.rankGT r then merge le t₁ (cons r a n t₂) else cons r a n (merge le t₁ t₂)).realSize =
    s₁.realSize + s₂.realSize
tactic: unfold merge
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
⊢ (match s₁, s₂ with
      | nil, h => h
      | h, nil => h
      | s₁@h:(cons r₁ a₁ n₁ t₁), s₂@h_1:(cons r₂ a₂ n₂ t₂) =>
        if r₁ < r₂ then cons r₁ a₁ n₁ (merge le t₁ s₂)
        else
          if r₂ < r₁ then cons r₂ a₂ n₂ (merge le s₁ t₂)
          else
            match combine le a₁ a₂ n₁ n₂ with
            | (a, n) =>
              let r := r₁ + 1;
              if t₁.rankGT r then if t₂.rankGT r then cons r a n (merge le t₁ t₂) else merge le (cons r a n t₁) t₂
              else if t₂.rankGT r then merge le t₁ (cons r a n t₂) else cons r a n (merge le t₁ t₂)).realSize =
    s₁.realSize + s₂.realSize
state_after: case h_1
α : Type u_1
le : α → α → Bool
s₂ x✝¹ x✝ : Heap α
⊢ s₂.realSize = nil.realSize + s₂.realSize

case h_2
α : Type u_1
le : α → α → Bool
s₁ x✝² x✝¹ : Heap α
x✝ : s₁ = nil → False
⊢ s₁.realSize = s₁.realSize + nil.realSize

case h_3
α : Type u_1
le : α → α → Bool
x✝¹ x✝ : Heap α
r₁✝ : Nat
a₁✝ : α
n₁✝ : HeapNode α
t₁✝ : Heap α
r₂✝ : Nat
a₂✝ : α
n₂✝ : HeapNode α
t₂✝ : Heap α
⊢ (if r₁✝ < r₂✝ then cons r₁✝ a₁✝ n₁✝ (merge le t₁✝ (cons r₂✝ a₂✝ n₂✝ t₂✝))
      else
        if r₂✝ < r₁✝ then cons r₂✝ a₂✝ n₂✝ (merge le (cons r₁✝ a₁✝ n₁✝ t₁✝) t₂✝)
        else
          match combine le a₁✝ a₂✝ n₁✝ n₂✝ with
          | (a, n) =>
            let r := r₁✝ + 1;
            if t₁✝.rankGT r then if t₂✝.rankGT r then cons r a n (merge le t₁✝ t₂✝) else merge le (cons r a n t₁✝) t₂✝
            else if t₂✝.rankGT r then merge le t₁✝ (cons r a n t₂✝) else cons r a n (merge le t₁✝ t₂✝)).realSize =
    (cons r₁✝ a₁✝ n₁✝ t₁✝).realSize + (cons r₂✝ a₂✝ n₂✝ t₂✝).realSize
tactic: split
Theorem: List.Nodup.getEquiv_apply_coe
File: Mathlib/Data/List/NodupEquivFin.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
H : l.Nodup
i : Fin l.length
⊢ (fun x => ⟨indexOf (↑x) l, ⋯⟩) ((fun i => ⟨l.get i, ⋯⟩) i) = i
state_after: no goals
tactic: simp only [List.get_indexOf, eq_self_iff_true, Fin.eta, Subtype.coe_mk, H]
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
H : l.Nodup
x : { x // x ∈ l }
⊢ (fun i => ⟨l.get i, ⋯⟩) ((fun x => ⟨indexOf (↑x) l, ⋯⟩) x) = x
state_after: no goals
tactic: simp
Theorem: isSepClosed_iff_isPurelyInseparable_algebraicClosure
File: Mathlib/FieldTheory/PurelyInseparable.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
inst✝ : IsAlgClosure F E
H : IsPurelyInseparable F E
⊢ IsSepClosed F
state_after: F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
inst✝ : IsAlgClosure F E
H : IsPurelyInseparable F E
this : IsAlgClosed E
⊢ IsSepClosed F
tactic: haveI := IsAlgClosure.alg_closed F (K := E)
state_before: F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
inst✝ : IsAlgClosure F E
H : IsPurelyInseparable F E
this : IsAlgClosed E
⊢ IsSepClosed F
state_after: no goals
tactic: rwa [← separableClosure.eq_bot_iff, IsSepClosed.separableClosure_eq_bot_iff] at H
Theorem: Polynomial.monomial_natDegree_leadingCoeff_eq_self
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.support.card ≤ 1
⊢ (monomial p.natDegree) p.leadingCoeff = p
state_after: no goals
tactic: classical
  rcases card_support_le_one_iff_monomial.1 h with ⟨n, a, rfl⟩
  by_cases ha : a = 0 <;> simp [ha]
Theorem: isSeparatedMap_iff_disjoint_nhds
File: Mathlib/Topology/SeparatedMap.lean

Proof steps:
state_before: X : Type u_1
Y : Sort u_2
A : Type ?u.5630
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
x x' : X
x✝ : f x = f x'
⊢ (x ≠ x' → ∃ s₁ s₂, IsOpen s₁ ∧ IsOpen s₂ ∧ x ∈ s₁ ∧ x' ∈ s₂ ∧ Disjoint s₁ s₂) ↔ x ≠ x' → Disjoint (𝓝 x) (𝓝 x')
state_after: no goals
tactic: simp only [(nhds_basis_opens x).disjoint_iff (nhds_basis_opens x'),
    exists_prop, ← exists_and_left, and_assoc, and_comm, and_left_comm]