ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.upShadow_compls
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ ∂⁺ 𝒜ᶜˢ = (∂ 𝒜)ᶜˢ
state_after: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ s ∈ ∂⁺ 𝒜ᶜˢ ↔ s ∈ (∂ 𝒜)ᶜˢ
tactic: ext s
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ s ∈ ∂⁺ 𝒜ᶜˢ ↔ s ∈ (∂ 𝒜)ᶜˢ
state_after: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ s_1, s_1ᶜ ∈ 𝒜 ∧ ∃ a ∉ s_1, insert a s_1 = s) ↔ ∃ s_1 ∈ 𝒜, ∃ a ∈ s_1, s_1.erase a = sᶜ
tactic: simp only [mem_image, exists_prop, mem_shadow_iff, mem_upShadow_iff, mem_compls]
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ s_1, s_1ᶜ ∈ 𝒜 ∧ ∃ a ∉ s_1, insert a s_1 = s) ↔ ∃ s_1 ∈ 𝒜, ∃ a ∈ s_1, s_1.erase a = sᶜ
state_after: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ b,
      ((Equiv.symm (Function.Involutive.toPerm compl ⋯)) b)ᶜ ∈ 𝒜 ∧
        ∃ a ∉ (Equiv.symm (Function.Involutive.toPerm compl ⋯)) b,
          insert a ((Equiv.symm (Function.Involutive.toPerm compl ⋯)) b) = s) ↔
    ∃ s_1 ∈ 𝒜, ∃ a ∈ s_1, s_1.erase a = sᶜ
tactic: refine (compl_involutive.toPerm _).exists_congr_left.trans ?_
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ b,
      ((Equiv.symm (Function.Involutive.toPerm compl ⋯)) b)ᶜ ∈ 𝒜 ∧
        ∃ a ∉ (Equiv.symm (Function.Involutive.toPerm compl ⋯)) b,
          insert a ((Equiv.symm (Function.Involutive.toPerm compl ⋯)) b) = s) ↔
    ∃ s_1 ∈ 𝒜, ∃ a ∈ s_1, s_1.erase a = sᶜ
state_after: no goals
tactic: simp [← compl_involutive.eq_iff]
Theorem: CategoryTheory.isCodetector_unop_iff
File: Mathlib/CategoryTheory/Generator.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : Cᵒᵖ
⊢ IsCodetector (unop G) ↔ IsDetector G
state_after: no goals
tactic: rw [IsDetector, IsCodetector, ← isCodetecting_unop_iff, Set.singleton_unop]
Theorem: Monoid.Coprod.mrange_lift
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : Monoid P
f : M →* P
g : N →* P
⊢ MonoidHom.mrange (lift f g) = MonoidHom.mrange f ⊔ MonoidHom.mrange g
state_after: no goals
tactic: simp [mrange_eq]
Theorem: edist_le_ofReal
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y : α
r : ℝ
hr : 0 ≤ r
⊢ edist x y ≤ ENNReal.ofReal r ↔ dist x y ≤ r
state_after: no goals
tactic: rw [edist_dist, ENNReal.ofReal_le_ofReal_iff hr]
Theorem: inv_lt_iff_one_lt_mul'
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a * a⁻¹ < a * b ↔ 1 < a * b
state_after: no goals
tactic: rw [mul_inv_self]
Theorem: Finset.Ioc_union_Ioc_eq_Ioc
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
h₁ : a ≤ b
h₂ : b ≤ c
⊢ Ioc a b ∪ Ioc b c = Ioc a c
state_after: no goals
tactic: rw [← coe_inj, coe_union, coe_Ioc, coe_Ioc, coe_Ioc, Set.Ioc_union_Ioc_eq_Ioc h₁ h₂]
Theorem: MeasureTheory.integral_comp_rpow_Ioi_of_pos
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

Proof steps:
state_before: E : Type u_1
f : ℝ → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
g : ℝ → E
p : ℝ
hp : 0 < p
⊢ ∫ (x : ℝ) in Ioi 0, (p * x ^ (p - 1)) • g (x ^ p) = ∫ (y : ℝ) in Ioi 0, g y
state_after: case h.e'_2.h.e'_7.h.h.e'_5.h.e'_5
E : Type u_1
f : ℝ → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
g : ℝ → E
p : ℝ
hp : 0 < p
x✝ : ℝ
⊢ p = |p|
tactic: convert integral_comp_rpow_Ioi g hp.ne'
state_before: case h.e'_2.h.e'_7.h.h.e'_5.h.e'_5
E : Type u_1
f : ℝ → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
g : ℝ → E
p : ℝ
hp : 0 < p
x✝ : ℝ
⊢ p = |p|
state_after: no goals
tactic: rw [abs_of_nonneg hp.le]
Theorem: Subsemiring.op_closure
File: Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean

Proof steps:
state_before: ι : Sort u_1
R : Type u_2
inst✝ : NonAssocSemiring R
s : Set R
⊢ (closure s).op = closure (MulOpposite.unop ⁻¹' s)
state_after: ι : Sort u_1
R : Type u_2
inst✝ : NonAssocSemiring R
s : Set R
⊢ sInf {a | s ⊆ MulOpposite.op ⁻¹' ↑a} = sInf {S | MulOpposite.unop ⁻¹' s ⊆ ↑S}
tactic: simp_rw [closure, op_sInf, Set.preimage_setOf_eq, unop_coe]
state_before: ι : Sort u_1
R : Type u_2
inst✝ : NonAssocSemiring R
s : Set R
⊢ sInf {a | s ⊆ MulOpposite.op ⁻¹' ↑a} = sInf {S | MulOpposite.unop ⁻¹' s ⊆ ↑S}
state_after: case e_a.h
ι : Sort u_1
R : Type u_2
inst✝ : NonAssocSemiring R
s : Set R
a : Subsemiring Rᵐᵒᵖ
⊢ a ∈ {a | s ⊆ MulOpposite.op ⁻¹' ↑a} ↔ a ∈ {S | MulOpposite.unop ⁻¹' s ⊆ ↑S}
tactic: congr with a
state_before: case e_a.h
ι : Sort u_1
R : Type u_2
inst✝ : NonAssocSemiring R
s : Set R
a : Subsemiring Rᵐᵒᵖ
⊢ a ∈ {a | s ⊆ MulOpposite.op ⁻¹' ↑a} ↔ a ∈ {S | MulOpposite.unop ⁻¹' s ⊆ ↑S}
state_after: no goals
tactic: exact MulOpposite.unop_surjective.forall
Theorem: Cardinal.toNat_eq_one
File: Mathlib/SetTheory/Cardinal/ToNat.lean

Proof steps:
state_before: α : Type u
c d : Cardinal.{u}
⊢ toNat c = 1 ↔ c = 1
state_after: no goals
tactic: rw [toNat_eq_iff one_ne_zero, Nat.cast_one]
Theorem: CategoryTheory.ShortComplex.SnakeInput.L₁_f_φ₁
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ S.L₀'.f ≫ S.φ₁ = S.v₁₂.τ₁
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ pullback.lift S.L₁.f 0 ⋯ ≫ S.φ₁ = S.v₁₂.τ₁
tactic: dsimp only [L₀']
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ pullback.lift S.L₁.f 0 ⋯ ≫ S.φ₁ = S.v₁₂.τ₁
state_after: no goals
tactic: simp only [← cancel_mono S.L₂.f, assoc, φ₁_L₂_f, φ₂, pullback.lift_fst_assoc,
    S.v₁₂.comm₁₂]
Theorem: EuclideanGeometry.inversion_mul
File: Mathlib/Geometry/Euclidean/Inversion/Basic.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
a✝ b c✝ d x✝ y z : P
r R✝ : ℝ
c : P
a R : ℝ
x : P
⊢ inversion c (a * R) x = (homothety c (a ^ 2)) (inversion c R x)
state_after: no goals
tactic: simp only [inversion_eq_lineMap, ← homothety_eq_lineMap, ← homothety_mul_apply, mul_div_assoc,
    mul_pow]
Theorem: Lagrange.nodal_subgroup_eq_X_pow_card_sub_one
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝¹ : IsDomain R
G : Subgroup Rˣ
inst✝ : Fintype ↥G
⊢ nodal (↑G).toFinset Units.val = X ^ Fintype.card ↥G - 1
state_after: R : Type u_1
inst✝² : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝¹ : IsDomain R
G : Subgroup Rˣ
inst✝ : Fintype ↥G
h : degree 1 < (X ^ Fintype.card ↥G).degree
⊢ nodal (↑G).toFinset Units.val = X ^ Fintype.card ↥G - 1
tactic: have h : degree (1 : R[X]) < degree ((X : R[X]) ^ Fintype.card G) := by simp [Fintype.card_pos]
state_before: R : Type u_1
inst✝² : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝¹ : IsDomain R
G : Subgroup Rˣ
inst✝ : Fintype ↥G
h : degree 1 < (X ^ Fintype.card ↥G).degree
⊢ nodal (↑G).toFinset Units.val = X ^ Fintype.card ↥G - 1
state_after: case hvs
R : Type u_1
inst✝² : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝¹ : IsDomain R
G : Subgroup Rˣ
inst✝ : Fintype ↥G
h : degree 1 < (X ^ Fintype.card ↥G).degree
⊢ Set.InjOn Units.val ↑(↑G).toFinset

case h_deg_le
R : Type u_1
inst✝² : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝¹ : IsDomain R
G : Subgroup Rˣ
inst✝ : Fintype ↥G
h : degree 1 < (X ^ Fintype.card ↥G).degree
⊢ (nodal (↑G).toFinset Units.val).degree ≤ ↑(↑G).toFinset.card

case h_deg_eq
R : Type u_1
inst✝² : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝¹ : IsDomain R
G : Subgroup Rˣ
inst✝ : Fintype ↥G
h : degree 1 < (X ^ Fintype.card ↥G).degree
⊢ (nodal (↑G).toFinset Units.val).degree = (X ^ Fintype.card ↥G - 1).degree

case hlc
R : Type u_1
inst✝² : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝¹ : IsDomain R
G : Subgroup Rˣ
inst✝ : Fintype ↥G
h : degree 1 < (X ^ Fintype.card ↥G).degree
⊢ (nodal (↑G).toFinset Units.val).leadingCoeff = (X ^ Fintype.card ↥G - 1).leadingCoeff

case h_eval
R : Type u_1
inst✝² : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝¹ : IsDomain R
G : Subgroup Rˣ
inst✝ : Fintype ↥G
h : degree 1 < (X ^ Fintype.card ↥G).degree
⊢ ∀ i ∈ (↑G).toFinset, eval (↑i) (nodal (↑G).toFinset Units.val) = eval (↑i) (X ^ Fintype.card ↥G - 1)
tactic: apply eq_of_degree_le_of_eval_index_eq (v := ((↑) : Rˣ → R)) (G : Set Rˣ).toFinset
Theorem: MvPolynomial.monomial_one_dvd_monomial_one
File: Mathlib/Algebra/MvPolynomial/Division.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
i j : σ →₀ ℕ
⊢ (monomial i) 1 ∣ (monomial j) 1 ↔ i ≤ j
state_after: σ : Type u_1
R : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
i j : σ →₀ ℕ
⊢ (1 = 0 ∨ i ≤ j) ∧ 1 ∣ 1 ↔ i ≤ j
tactic: rw [monomial_dvd_monomial]
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Nontrivial R
i j : σ →₀ ℕ
⊢ (1 = 0 ∨ i ≤ j) ∧ 1 ∣ 1 ↔ i ≤ j
state_after: no goals
tactic: simp_rw [one_ne_zero, false_or_iff, dvd_rfl, and_true_iff]
Theorem: CategoryTheory.coherentTopology.presheafIsLocallySurjective_iff
File: Mathlib/CategoryTheory/Sites/Coherent/LocallySurjective.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{u_4, u_2} D
inst✝⁵ : ConcreteCategory D
F G : Cᵒᵖ ⥤ D
f : F ⟶ G
inst✝⁴ : Preregular C
inst✝³ : FinitaryPreExtensive C
inst✝² : PreservesFiniteProducts F
inst✝¹ : PreservesFiniteProducts G
inst✝ : PreservesFiniteProducts (forget D)
⊢ Presheaf.IsLocallySurjective (coherentTopology C) f ↔ Presheaf.IsLocallySurjective (regularTopology C) f
state_after: case mp
C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{u_4, u_2} D
inst✝⁵ : ConcreteCategory D
F G : Cᵒᵖ ⥤ D
f : F ⟶ G
inst✝⁴ : Preregular C
inst✝³ : FinitaryPreExtensive C
inst✝² : PreservesFiniteProducts F
inst✝¹ : PreservesFiniteProducts G
inst✝ : PreservesFiniteProducts (forget D)
⊢ Presheaf.IsLocallySurjective (coherentTopology C) f → Presheaf.IsLocallySurjective (regularTopology C) f

case mpr
C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_3, u_1} C
inst✝⁶ : Category.{u_4, u_2} D
inst✝⁵ : ConcreteCategory D
F G : Cᵒᵖ ⥤ D
f : F ⟶ G
inst✝⁴ : Preregular C
inst✝³ : FinitaryPreExtensive C
inst✝² : PreservesFiniteProducts F
inst✝¹ : PreservesFiniteProducts G
inst✝ : PreservesFiniteProducts (forget D)
⊢ Presheaf.IsLocallySurjective (regularTopology C) f → Presheaf.IsLocallySurjective (coherentTopology C) f
tactic: constructor
Theorem: MeasureTheory.memℒp_finset_sum
File: Mathlib/MeasureTheory/Function/LpSeminorm/TriangleInequality.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
q : ℝ
μ : Measure α
f✝ g : α → E
ι : Type u_3
s : Finset ι
f : ι → α → E
hf : ∀ i ∈ s, Memℒp (f i) p μ
⊢ Memℒp (fun a => ∑ i ∈ s, f i a) p μ
state_after: α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
q : ℝ
μ : Measure α
f✝ g : α → E
ι : Type u_3
s : Finset ι
f : ι → α → E
hf : ∀ i ∈ s, Memℒp (f i) p μ
this : DecidableEq ι
⊢ Memℒp (fun a => ∑ i ∈ s, f i a) p μ
tactic: haveI : DecidableEq ι := Classical.decEq _
state_before: α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
q : ℝ
μ : Measure α
f✝ g : α → E
ι : Type u_3
s : Finset ι
f : ι → α → E
hf : ∀ i ∈ s, Memℒp (f i) p μ
this : DecidableEq ι
⊢ Memℒp (fun a => ∑ i ∈ s, f i a) p μ
state_after: α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
q : ℝ
μ : Measure α
f✝ g : α → E
ι : Type u_3
s : Finset ι
f : ι → α → E
this : DecidableEq ι
⊢ (∀ i ∈ s, Memℒp (f i) p μ) → Memℒp (fun a => ∑ i ∈ s, f i a) p μ
tactic: revert hf
state_before: α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
q : ℝ
μ : Measure α
f✝ g : α → E
ι : Type u_3
s : Finset ι
f : ι → α → E
this : DecidableEq ι
⊢ (∀ i ∈ s, Memℒp (f i) p μ) → Memℒp (fun a => ∑ i ∈ s, f i a) p μ
state_after: case refine_1
α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
q : ℝ
μ : Measure α
f✝ g : α → E
ι : Type u_3
s : Finset ι
f : ι → α → E
this : DecidableEq ι
⊢ (∀ i ∈ ∅, Memℒp (f i) p μ) → Memℒp (fun a => ∑ i ∈ ∅, f i a) p μ

case refine_2
α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
q : ℝ
μ : Measure α
f✝ g : α → E
ι : Type u_3
s : Finset ι
f : ι → α → E
this : DecidableEq ι
⊢ ∀ ⦃a : ι⦄ {s : Finset ι},
    a ∉ s →
      ((∀ i ∈ s, Memℒp (f i) p μ) → Memℒp (fun a => ∑ i ∈ s, f i a) p μ) →
        (∀ i ∈ insert a s, Memℒp (f i) p μ) → Memℒp (fun a_3 => ∑ i ∈ insert a s, f i a_3) p μ
tactic: refine Finset.induction_on s ?_ ?_
Theorem: Sym.ofVector_cons
File: Mathlib/Data/Sym/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a✝ b a : α
v : Vector α n
⊢ ofVector (a ::ᵥ v) = a ::ₛ ofVector v
state_after: case mk
α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a✝ b a : α
val✝ : List α
property✝ : val✝.length = n
⊢ ofVector (a ::ᵥ ⟨val✝, property✝⟩) = a ::ₛ ofVector ⟨val✝, property✝⟩
tactic: cases v
state_before: case mk
α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a✝ b a : α
val✝ : List α
property✝ : val✝.length = n
⊢ ofVector (a ::ᵥ ⟨val✝, property✝⟩) = a ::ₛ ofVector ⟨val✝, property✝⟩
state_after: no goals
tactic: rfl
Theorem: Metric.diam_closure
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PseudoEMetricSpace α✝
α : Type u_4
inst✝ : PseudoMetricSpace α
s : Set α
⊢ diam (closure s) = diam s
state_after: no goals
tactic: simp only [Metric.diam, EMetric.diam_closure]
Theorem: DFinsupp.neLocus_zero_right
File: Mathlib/Data/DFinsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → Zero (N a)
f g : Π₀ (a : α), N a
⊢ f.neLocus 0 = f.support
state_after: case a
α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → Zero (N a)
f g : Π₀ (a : α), N a
a✝ : α
⊢ a✝ ∈ f.neLocus 0 ↔ a✝ ∈ f.support
tactic: ext
state_before: case a
α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → Zero (N a)
f g : Π₀ (a : α), N a
a✝ : α
⊢ a✝ ∈ f.neLocus 0 ↔ a✝ ∈ f.support
state_after: no goals
tactic: rw [mem_neLocus, mem_support_iff, coe_zero, Pi.zero_apply]
Theorem: Monoid.CoprodI.Word.rcons_eq_smul
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i : ι
p : Pair M i
⊢ rcons p = of p.head • p.tail
state_after: no goals
tactic: simp [of_smul_def]
Theorem: le_iff_exists_mul
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c d : α
⊢ (∃ c, b = a * c) → a ≤ b
state_after: case intro
α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a c✝ d c : α
⊢ a ≤ a * c
tactic: rintro ⟨c, rfl⟩
state_before: case intro
α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a c✝ d c : α
⊢ a ≤ a * c
state_after: no goals
tactic: exact le_self_mul
Theorem: HahnSeries.orderTop_neg
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddGroup R
x : HahnSeries Γ R
⊢ (-x).orderTop = x.orderTop
state_after: no goals
tactic: simp only [orderTop, support_neg, neg_eq_zero]
Theorem: ComplexShape.symm_symm
File: Mathlib/Algebra/Homology/ComplexShape.lean

Proof steps:
state_before: ι : Type u_1
c : ComplexShape ι
⊢ c.symm.symm = c
state_after: case Rel.h.h.a
ι : Type u_1
c : ComplexShape ι
x✝¹ x✝ : ι
⊢ c.symm.symm.Rel x✝¹ x✝ ↔ c.Rel x✝¹ x✝
tactic: ext
state_before: case Rel.h.h.a
ι : Type u_1
c : ComplexShape ι
x✝¹ x✝ : ι
⊢ c.symm.symm.Rel x✝¹ x✝ ↔ c.Rel x✝¹ x✝
state_after: no goals
tactic: simp
Theorem: Monoid.CoprodI.Word.empty_toList
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
⊢ ∀ l ∈ [], l.snd ≠ 1
state_after: no goals
tactic: simp
Theorem: OrthonormalBasis.orthonormal
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
b : OrthonormalBasis ι 𝕜 E
⊢ Orthonormal 𝕜 ⇑b
state_after: no goals
tactic: classical
    rw [orthonormal_iff_ite]
    intro i j
    rw [← b.repr.inner_map_map (b i) (b j), b.repr_self i, b.repr_self j,
      EuclideanSpace.inner_single_left, EuclideanSpace.single_apply, map_one, one_mul]
Theorem: Finset.empty_inter
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
s : Finset α
x✝ : α
⊢ x✝ ∈ ∅ ∧ x✝ ∈ s ↔ x✝ ∈ ∅
state_after: no goals
tactic: simp
Theorem: MeasureTheory.L1.SimpleFunc.integral_L1_eq_integral
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : ↥(simpleFunc E 1 μ)
⊢ L1.integral ↑f = integral f
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : ↥(simpleFunc E 1 μ)
⊢ L1.integralCLM ↑f = MeasureTheory.SimpleFunc.integral μ (toSimpleFunc f)
tactic: simp only [integral, L1.integral]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : ↥(simpleFunc E 1 μ)
⊢ L1.integralCLM ↑f = MeasureTheory.SimpleFunc.integral μ (toSimpleFunc f)
state_after: no goals
tactic: exact setToL1_eq_setToL1SCLM (dominatedFinMeasAdditive_weightedSMul μ) f
Theorem: Sum.Lex.Ico_inr_inr
File: Mathlib/Data/Sum/Interval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ico (inrₗ b₁) (inrₗ b₂) = map (Embedding.inr.trans toLex.toEmbedding) (Ico b₁ b₂)
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ico (inrₗ b₁) (inrₗ b₂) = map toLex.toEmbedding (map Embedding.inr (Ico b₁ b₂))
tactic: rw [← Finset.map_map]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ico (inrₗ b₁) (inrₗ b₂) = map toLex.toEmbedding (map Embedding.inr (Ico b₁ b₂))
state_after: no goals
tactic: rfl
Theorem: List.tails_append
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ ([] ++ []).tails = map (fun l => l ++ []) [].tails ++ [].tails.tail
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
a : α
t : List α
⊢ ([] ++ a :: t).tails = map (fun l => l ++ a :: t) [].tails ++ (a :: t).tails.tail
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
a : α
s t : List α
⊢ (a :: s ++ t).tails = map (fun l => l ++ t) (a :: s).tails ++ t.tails.tail
state_after: no goals
tactic: simp [tails_append s t]
Theorem: Associates.count_factors_eq_find_of_dvd_pow
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : UniqueFactorizationMonoid α
inst✝³ : DecidableEq (Associates α)
inst✝² : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : DecidableEq (Associates α)
a p : Associates α
hp : Irreducible p
inst✝ : (n : ℕ) → Decidable (a ∣ p ^ n)
n : ℕ
h : a ∣ p ^ n
⊢ Nat.find ⋯ = p.count a.factors
state_after: case a
α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : UniqueFactorizationMonoid α
inst✝³ : DecidableEq (Associates α)
inst✝² : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : DecidableEq (Associates α)
a p : Associates α
hp : Irreducible p
inst✝ : (n : ℕ) → Decidable (a ∣ p ^ n)
n : ℕ
h : a ∣ p ^ n
⊢ Nat.find ⋯ ≤ p.count a.factors

case a
α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : UniqueFactorizationMonoid α
inst✝³ : DecidableEq (Associates α)
inst✝² : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : DecidableEq (Associates α)
a p : Associates α
hp : Irreducible p
inst✝ : (n : ℕ) → Decidable (a ∣ p ^ n)
n : ℕ
h : a ∣ p ^ n
⊢ p.count a.factors ≤ Nat.find ⋯
tactic: apply le_antisymm
Theorem: ZMod.exponent
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a : α
n : ℕ
⊢ AddMonoid.exponent (ZMod n) = n
state_after: case zero
α : Type u
a : α
⊢ AddMonoid.exponent (ZMod 0) = 0

case succ
α : Type u
a : α
n✝ : ℕ
⊢ AddMonoid.exponent (ZMod (n✝ + 1)) = n✝ + 1
tactic: cases n