ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Pi.isTrichotomous_lex
File: Mathlib/Order/PiLex.lean

Proof steps:
state_before: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝ : ∀ (i : ι), IsTrichotomous (β i) s
wf : WellFounded r
a b : (i : ι) → β i
⊢ Pi.Lex r s a b ∨ a = b ∨ Pi.Lex r s b a
state_after: case inl
ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝ : ∀ (i : ι), IsTrichotomous (β i) s
wf : WellFounded r
a b : (i : ι) → β i
hab : a = b
⊢ Pi.Lex r s a b ∨ a = b ∨ Pi.Lex r s b a

case inr
ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝ : ∀ (i : ι), IsTrichotomous (β i) s
wf : WellFounded r
a b : (i : ι) → β i
hab : a ≠ b
⊢ Pi.Lex r s a b ∨ a = b ∨ Pi.Lex r s b a
tactic: rcases eq_or_ne a b with hab | hab
Theorem: Filter.disjoint_principal_left
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
f : Filter α
s : Set α
⊢ Disjoint (𝓟 s) f ↔ sᶜ ∈ f
state_after: no goals
tactic: rw [disjoint_comm, disjoint_principal_right]
Theorem: bernoulliFourierCoeff_eq
File: Mathlib/NumberTheory/ZetaValues.lean

Proof steps:
state_before: k : ℕ
hk : k ≠ 0
n : ℤ
⊢ bernoulliFourierCoeff k n = -↑k ! / (2 * ↑π * I * ↑n) ^ k
state_after: case inl
k : ℕ
hk : k ≠ 0
⊢ bernoulliFourierCoeff k 0 = -↑k ! / (2 * ↑π * I * ↑0) ^ k

case inr
k : ℕ
hk : k ≠ 0
n : ℤ
hn : n ≠ 0
⊢ bernoulliFourierCoeff k n = -↑k ! / (2 * ↑π * I * ↑n) ^ k
tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: case inr
k : ℕ
hk : k ≠ 0
n : ℤ
hn : n ≠ 0
⊢ bernoulliFourierCoeff k n = -↑k ! / (2 * ↑π * I * ↑n) ^ k
state_after: case inr.refine_1
k : ℕ
hk : k ≠ 0
n : ℤ
hn : n ≠ 0
⊢ bernoulliFourierCoeff 1 n = -↑1! / (2 * ↑π * I * ↑n) ^ 1

case inr.refine_2
k✝ : ℕ
hk✝ : k✝ ≠ 0
n : ℤ
hn : n ≠ 0
k : ℕ
hk : 1 ≤ k
h'k : bernoulliFourierCoeff k n = -↑k ! / (2 * ↑π * I * ↑n) ^ k
⊢ bernoulliFourierCoeff (k + 1) n = -↑(k + 1)! / (2 * ↑π * I * ↑n) ^ (k + 1)
tactic: refine Nat.le_induction ?_ (fun k hk h'k => ?_) k (Nat.one_le_iff_ne_zero.mpr hk)
Theorem: Cardinal.mk_preimage_of_injective
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
c : Cardinal.{?u.229352}
f : α → β
s : Set β
h : Injective f
⊢ #↑(f ⁻¹' s) ≤ #↑s
state_after: α β : Type u
c : Cardinal.{?u.229352}
f : α → β
s : Set β
h : Injective f
⊢ lift.{u, u} #↑(f ⁻¹' s) ≤ lift.{u, u} #↑s
tactic: rw [← lift_id #(↑(f ⁻¹' s)), ← lift_id #(↑s)]
state_before: α β : Type u
c : Cardinal.{?u.229352}
f : α → β
s : Set β
h : Injective f
⊢ lift.{u, u} #↑(f ⁻¹' s) ≤ lift.{u, u} #↑s
state_after: no goals
tactic: exact mk_preimage_of_injective_lift f s h
Theorem: Real.rpow_of_add_eq
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y✝ z✝ w x y z : ℝ
hx : 0 ≤ x
hw : w ≠ 0
h : y + z = w
⊢ x ^ w = x ^ y * x ^ z
state_after: x✝ y✝ z✝ w x y z : ℝ
hx : 0 ≤ x
hw : w ≠ 0
h : y + z = w
⊢ y + z ≠ 0
tactic: rw [← h, rpow_add' hx]
state_before: x✝ y✝ z✝ w x y z : ℝ
hx : 0 ≤ x
hw : w ≠ 0
h : y + z = w
⊢ y + z ≠ 0
state_after: no goals
tactic: rwa [h]
Theorem: Pell.eq_pell
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
x y : ℕ
hp✝ : x * x - Pell.d a1 * y * y = 1
hp : 0 - Pell.d a1 * y * y = 1
⊢ 1 ≤ { re := ↑0, im := ↑y }
state_after: a : ℕ
a1 : 1 < a
x y : ℕ
hp✝ : x * x - Pell.d a1 * y * y = 1
hp : 0 = 1
⊢ 1 ≤ { re := ↑0, im := ↑y }
tactic: rw [zero_tsub] at hp
state_before: a : ℕ
a1 : 1 < a
x y : ℕ
hp✝ : x * x - Pell.d a1 * y * y = 1
hp : 0 = 1
⊢ 1 ≤ { re := ↑0, im := ↑y }
state_after: no goals
tactic: contradiction
Theorem: Finmap.mem_erase
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
s✝ : Finmap β
s : AList β
⊢ a' ∈ erase a ⟦s⟧ ↔ a' ≠ a ∧ a' ∈ ⟦s⟧
state_after: no goals
tactic: simp
Theorem: Real.negMulLog_nonneg
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

Proof steps:
state_before: x : ℝ
h1 : 0 ≤ x
h2 : x ≤ 1
⊢ 0 ≤ x.negMulLog
state_after: no goals
tactic: simpa only [negMulLog_eq_neg, neg_nonneg] using mul_log_nonpos h1 h2
Theorem: MvPolynomial.weightedHomogeneousComponent_mem
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w✝ : σ → M
n : M
φ✝ ψ : MvPolynomial σ R
w : σ → M
φ : MvPolynomial σ R
m : M
⊢ (weightedHomogeneousComponent w m) φ ∈ weightedHomogeneousSubmodule R w m
state_after: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w✝ : σ → M
n : M
φ✝ ψ : MvPolynomial σ R
w : σ → M
φ : MvPolynomial σ R
m : M
⊢ IsWeightedHomogeneous w ((weightedHomogeneousComponent w m) φ) m
tactic: rw [mem_weightedHomogeneousSubmodule]
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w✝ : σ → M
n : M
φ✝ ψ : MvPolynomial σ R
w : σ → M
φ : MvPolynomial σ R
m : M
⊢ IsWeightedHomogeneous w ((weightedHomogeneousComponent w m) φ) m
state_after: no goals
tactic: exact weightedHomogeneousComponent_isWeightedHomogeneous m φ
Theorem: Polynomial.leadingCoeff_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
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
⊢ (p * q).leadingCoeff = p.leadingCoeff * q.leadingCoeff
state_after: case pos
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
hp : p = 0
⊢ (p * q).leadingCoeff = p.leadingCoeff * q.leadingCoeff

case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
hp : ¬p = 0
⊢ (p * q).leadingCoeff = p.leadingCoeff * q.leadingCoeff
tactic: by_cases hp : p = 0
Theorem: CategoryTheory.IsPushout.of_id_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
⊢ f ≫ 𝟙 X = 𝟙 Z ≫ f
state_after: no goals
tactic: simp
Theorem: Set.encard_insert_le
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
a b : α
s : Set α
x : α
⊢ (insert x s).encard ≤ s.encard + 1
state_after: α : Type u_1
β : Type u_2
s✝ t : Set α
a b : α
s : Set α
x : α
⊢ (s ∪ {x}).encard ≤ s.encard + {x}.encard
tactic: rw [← union_singleton, ← encard_singleton x]
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
a b : α
s : Set α
x : α
⊢ (s ∪ {x}).encard ≤ s.encard + {x}.encard
state_after: no goals
tactic: apply encard_union_le
Theorem: GradedRing.projZeroRingHom'_apply_coe
File: Mathlib/RingTheory/GradedAlgebra/Basic.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
σ : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : CanonicallyOrderedAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
a : ↥(𝒜 0)
⊢ (projZeroRingHom' 𝒜) ↑a = a
state_after: case a
ι : Type u_1
R : Type u_2
A : Type u_3
σ : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : CanonicallyOrderedAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
a : ↥(𝒜 0)
⊢ ↑((projZeroRingHom' 𝒜) ↑a) = ↑a
tactic: ext
state_before: case a
ι : Type u_1
R : Type u_2
A : Type u_3
σ : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : CanonicallyOrderedAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
a : ↥(𝒜 0)
⊢ ↑((projZeroRingHom' 𝒜) ↑a) = ↑a
state_after: no goals
tactic: simp only [coe_projZeroRingHom'_apply, projZeroRingHom_apply, decompose_coe, of_eq_same]
Theorem: Submodule.map₂_eq_span_image2
File: Mathlib/Algebra/Module/Submodule/Bilinear.lean

Proof steps:
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
p : Submodule R M
q : Submodule R N
⊢ map₂ f p q = span R (image2 (fun m n => (f m) n) ↑p ↑q)
state_after: no goals
tactic: rw [← map₂_span_span, span_eq, span_eq]
Theorem: Set.image2_left_comm
File: Mathlib/Data/Set/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f✝ f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
⊢ image2 f s (image2 g t u) = image2 g' t (image2 f' s u)
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f✝ f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
⊢ image2 (fun a b => f b a) (image2 g t u) s = image2 g' t (image2 (fun a b => f' b a) u s)
tactic: rw [image2_swap f', image2_swap f]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f✝ f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
⊢ image2 (fun a b => f b a) (image2 g t u) s = image2 g' t (image2 (fun a b => f' b a) u s)
state_after: no goals
tactic: exact image2_assoc fun _ _ _ => h_left_comm _ _ _
Theorem: PMF.bindOnSupport_pure
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : PMF α
f : (a : α) → a ∈ p✝.support → PMF β
p : PMF α
⊢ (p.bindOnSupport fun a x => pure a) = p
state_after: no goals
tactic: simp only [PMF.bind_pure, PMF.bindOnSupport_eq_bind]
Theorem: Real.map_matrix_volume_pi_eq_smul_volume_pi
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

Proof steps:
state_before: ι : Type u_1
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
M : Matrix ι ι ℝ
hM : M.det ≠ 0
⊢ Measure.map (⇑(toLin' M)) volume = ofReal |M.det⁻¹| • volume
state_after: case hdiag
ι : Type u_1
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
M : Matrix ι ι ℝ
hM : M.det ≠ 0
⊢ ∀ (D : ι → ℝ),
    (Matrix.diagonal D).det ≠ 0 →
      Measure.map (⇑(toLin' (Matrix.diagonal D))) volume = ofReal |(Matrix.diagonal D).det⁻¹| • volume

case htransvec
ι : Type u_1
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
M : Matrix ι ι ℝ
hM : M.det ≠ 0
⊢ ∀ (t : TransvectionStruct ι ℝ), Measure.map (⇑(toLin' t.toMatrix)) volume = ofReal |t.toMatrix.det⁻¹| • volume

case hmul
ι : Type u_1
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
M : Matrix ι ι ℝ
hM : M.det ≠ 0
⊢ ∀ (A B : Matrix ι ι ℝ),
    A.det ≠ 0 →
      B.det ≠ 0 →
        Measure.map (⇑(toLin' A)) volume = ofReal |A.det⁻¹| • volume →
          Measure.map (⇑(toLin' B)) volume = ofReal |B.det⁻¹| • volume →
            Measure.map (⇑(toLin' (A * B))) volume = ofReal |(A * B).det⁻¹| • volume
tactic: apply diagonal_transvection_induction_of_det_ne_zero _ M hM
Theorem: Cardinal.isRegular_aleph0
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
⊢ ℵ₀ ≤ ℵ₀.ord.cof
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.Concrete.prodEquiv_symm_apply_snd
File: Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
X₁ X₂ : C
inst✝¹ : HasBinaryProduct X₁ X₂
inst✝ : PreservesLimit (pair X₁ X₂) (forget C)
x : (forget C).obj X₁ × (forget C).obj X₂
⊢ prod.snd ((prodEquiv X₁ X₂).symm x) = x.2
state_after: case intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
X₁ X₂ : C
inst✝¹ : HasBinaryProduct X₁ X₂
inst✝ : PreservesLimit (pair X₁ X₂) (forget C)
y : (forget C).obj (X₁ ⨯ X₂)
⊢ prod.snd ((prodEquiv X₁ X₂).symm ((prodEquiv X₁ X₂) y)) = ((prodEquiv X₁ X₂) y).2
tactic: obtain ⟨y, rfl⟩ := (prodEquiv X₁ X₂).surjective x
state_before: case intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
X₁ X₂ : C
inst✝¹ : HasBinaryProduct X₁ X₂
inst✝ : PreservesLimit (pair X₁ X₂) (forget C)
y : (forget C).obj (X₁ ⨯ X₂)
⊢ prod.snd ((prodEquiv X₁ X₂).symm ((prodEquiv X₁ X₂) y)) = ((prodEquiv X₁ X₂) y).2
state_after: no goals
tactic: simp
Theorem: Real.cauchy_sub
File: Mathlib/Data/Real/Basic.lean

Proof steps:
state_before: x y : ℝ
a b : Cauchy abs
⊢ ({ cauchy := a } - { cauchy := b }).cauchy = { cauchy := a }.cauchy - { cauchy := b }.cauchy
state_after: x y : ℝ
a b : Cauchy abs
⊢ ({ cauchy := a } - { cauchy := b }).cauchy = ({ cauchy := a } + -{ cauchy := b }).cauchy
tactic: rw [sub_eq_add_neg, ← cauchy_neg, ← cauchy_add]
state_before: x y : ℝ
a b : Cauchy abs
⊢ ({ cauchy := a } - { cauchy := b }).cauchy = ({ cauchy := a } + -{ cauchy := b }).cauchy
state_after: no goals
tactic: rfl
Theorem: ZMod.mul_inv_of_unit
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
a : ZMod n
h : IsUnit a
⊢ a * a⁻¹ = 1
state_after: case intro
m n✝ n : ℕ
u : (ZMod n)ˣ
⊢ ↑u * (↑u)⁻¹ = 1
tactic: rcases h with ⟨u, rfl⟩
state_before: case intro
m n✝ n : ℕ
u : (ZMod n)ˣ
⊢ ↑u * (↑u)⁻¹ = 1
state_after: no goals
tactic: rw [inv_coe_unit, u.mul_inv]
Theorem: Quiver.SingleObj.listToPath_pathToList
File: Mathlib/Combinatorics/Quiver/SingleObj.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
x : SingleObj α
p : Path (star α) x
⊢ listToPath (pathToList p) = Path.cast ⋯ ⋯ p
state_after: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
x : SingleObj α
⊢ listToPath (pathToList Path.nil) = Path.cast ⋯ ⋯ Path.nil

case cons
α : Type u_1
β : Type u_2
γ : Type u_3
x y z : SingleObj α
p : Path (star α) y
a : y ⟶ z
ih : listToPath (pathToList p) = Path.cast ⋯ ⋯ p
⊢ listToPath (pathToList (p.cons a)) = Path.cast ⋯ ⋯ (p.cons a)
tactic: induction' p with y z p a ih
Theorem: CauSeq.smul_equiv_smul
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : LinearOrderedField α
inst✝³ : Ring β
abv : β → α
inst✝² : IsAbsoluteValue abv
G : Type u_3
inst✝¹ : SMul G β
inst✝ : IsScalarTower G β β
f1 f2 : CauSeq β abv
c : G
hf : f1 ≈ f2
⊢ c • f1 ≈ c • f2
state_after: no goals
tactic: simpa [const_smul, smul_one_mul _ _] using
    mul_equiv_mul (const_equiv.mpr <| Eq.refl <| c • (1 : β)) hf
Theorem: le_mul_right
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : CanonicallyOrderedCommMonoid α
a b c d : α
h : a ≤ b
⊢ a = a * 1
state_after: no goals
tactic: simp
Theorem: List.countP_join
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
p : α → Bool
a : List α
l : List (List α)
⊢ countP p (a :: l).join = (map (countP p) (a :: l)).sum
state_after: no goals
tactic: rw [join, countP_append, map_cons, sum_cons, countP_join _ l]
Theorem: SimpleGraph.Walk.map_isCycle_iff_of_injective
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p✝ : G.Walk u v
p : G.Walk u u
hinj : Injective ⇑f
⊢ (Walk.map f p).IsCycle ↔ p.IsCycle
state_after: no goals
tactic: rw [isCycle_def, isCycle_def, map_isTrail_iff_of_injective hinj, Ne, map_eq_nil_iff,
    support_map, ← List.map_tail, List.nodup_map_iff hinj]
Theorem: Int.one_ne_zero
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n : ℤ
⊢ 1 ≠ 0
state_after: no goals
tactic: decide
Theorem: List.map_erase
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
finj : Injective f
a : α
l : List α
this : (fun x => a == x) = fun x => f a == f x
⊢ map f (l.erase a) = (map f l).erase (f a)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
finj : Injective f
a : α
l : List α
this : (fun x => a == x) = fun x => f a == f x
⊢ map f (eraseP (fun x => f a == f x) l) = map f (eraseP ((fun x => f a == x) ∘ f) l)
tactic: rw [erase_eq_eraseP, erase_eq_eraseP, eraseP_map, this]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
finj : Injective f
a : α
l : List α
this : (fun x => a == x) = fun x => f a == f x
⊢ map f (eraseP (fun x => f a == f x) l) = map f (eraseP ((fun x => f a == x) ∘ f) l)
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.hitting_of_le
File: Mathlib/Probability/Process/HittingTime.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
hmn : m ≤ n
⊢ hitting u s n m ω = m
state_after: case inl
Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
i : ι
ω : Ω
m : ι
hmn : m ≤ m
⊢ hitting u s m m ω = m

case inr
Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
hmn : m ≤ n
h : m < n
⊢ hitting u s n m ω = m
tactic: obtain rfl | h := le_iff_eq_or_lt.1 hmn
Theorem: TopologicalSpace.Opens.mapMapIso_functor
File: Mathlib/Topology/Category/TopCat/Opens.lean

Proof steps:
state_before: X✝ Y✝ Z X Y : TopCat
H : X ≅ Y
U : Opens ↑Y
⊢ (𝟭 (Opens ↑Y)).obj U = (map H.hom ⋙ map H.inv).obj U
state_after: no goals
tactic: simp [map, Set.preimage_preimage]
state_before: X✝ Y✝ Z X Y : TopCat
H : X ≅ Y
U : Opens ↑X
⊢ (map H.inv ⋙ map H.hom).obj U = (𝟭 (Opens ↑X)).obj U
state_after: no goals
tactic: simp [map, Set.preimage_preimage]
Theorem: negPart_pos
File: Mathlib/Algebra/Order/Group/PosPart.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Lattice α
inst✝¹ : Group α
a : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
ha : a < 1
⊢ 1 < a⁻ᵐ
state_after: no goals
tactic: rwa [leOnePart_eq_inv.2 ha.le, one_lt_inv']
Theorem: CategoryTheory.CommSq.LiftStruct.unop_l
File: Mathlib/CategoryTheory/CommSq.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.9360, u_1} C
A✝ B✝ X✝ Y✝ : C
f✝ : A✝ ⟶ X✝
i✝ : A✝ ⟶ B✝
p✝ : X✝ ⟶ Y✝
g✝ : B✝ ⟶ Y✝
A B X Y : Cᵒᵖ
f : A ⟶ X
i : A ⟶ B
p : X ⟶ Y
g : B ⟶ Y
sq : CommSq f i p g
l : sq.LiftStruct
⊢ p.unop ≫ l.l.unop = g.unop
state_after: no goals
tactic: rw [← unop_comp, l.fac_right]
state_before: C : Type u_1
inst✝ : Category.{?u.9360, u_1} C
A✝ B✝ X✝ Y✝ : C
f✝ : A✝ ⟶ X✝
i✝ : A✝ ⟶ B✝
p✝ : X✝ ⟶ Y✝
g✝ : B✝ ⟶ Y✝
A B X Y : Cᵒᵖ
f : A ⟶ X
i : A ⟶ B
p : X ⟶ Y
g : B ⟶ Y
sq : CommSq f i p g
l : sq.LiftStruct
⊢ l.l.unop ≫ i.unop = f.unop
state_after: no goals
tactic: rw [← unop_comp, l.fac_left]
Theorem: Matrix.IsHermitian.eigenvalues_eq_spectrum_real
File: Mathlib/LinearAlgebra/Matrix/HermitianFunctionalCalculus.lean

Proof steps:
state_before: n : Type u_1
𝕜 : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.IsHermitian
a : Matrix n n 𝕜
ha : a.IsHermitian
⊢ spectrum ℝ a = Set.range ha.eigenvalues
state_after: case h
n : Type u_1
𝕜 : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.IsHermitian
a : Matrix n n 𝕜
ha : a.IsHermitian
x : ℝ
⊢ x ∈ spectrum ℝ a ↔ x ∈ Set.range ha.eigenvalues
tactic: ext x
state_before: case h
n : Type u_1
𝕜 : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.IsHermitian
a : Matrix n n 𝕜
ha : a.IsHermitian
x : ℝ
⊢ x ∈ spectrum ℝ a ↔ x ∈ Set.range ha.eigenvalues
state_after: case h
n : Type u_1
𝕜 : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.IsHermitian
a : Matrix n n 𝕜
ha : a.IsHermitian
x : ℝ
⊢ ↑x ∈ Set.range (RCLike.ofReal ∘ ha.eigenvalues) ↔ x ∈ Set.range ha.eigenvalues
tactic: conv_lhs => rw [ha.spectral_theorem, unitary.spectrum.unitary_conjugate,
  ← spectrum.algebraMap_mem_iff 𝕜, spectrum_diagonal, RCLike.algebraMap_eq_ofReal]
state_before: case h
n : Type u_1
𝕜 : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.IsHermitian
a : Matrix n n 𝕜
ha : a.IsHermitian
x : ℝ
⊢ ↑x ∈ Set.range (RCLike.ofReal ∘ ha.eigenvalues) ↔ x ∈ Set.range ha.eigenvalues
state_after: no goals
tactic: simp
Theorem: Fintype.prod_eq_one_iff_of_one_le
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : Fintype ι
inst✝ : OrderedCommMonoid M
f : ι → M
hf : 1 ≤ f
⊢ (∀ i ∈ Finset.univ, f i = 1) ↔ f = 1
state_after: no goals
tactic: simp [Function.funext_iff]
Theorem: CategoryTheory.Limits.kernel.mapIso_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝¹ : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝ : HasKernel f'
p : X ≅ X'
q : Y ≅ Y'
w : f ≫ q.hom = p.hom ≫ f'
⊢ f' ≫ q.inv = p.inv ≫ f
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝¹ : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝ : HasKernel f'
p : X ≅ X'
q : Y ≅ Y'
w : f ≫ q.hom = p.hom ≫ f'
⊢ (f' ≫ q.inv) ≫ q.hom = (p.inv ≫ f) ≫ q.hom
tactic: refine (cancel_mono q.hom).1 ?_
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝¹ : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝ : HasKernel f'
p : X ≅ X'
q : Y ≅ Y'
w : f ≫ q.hom = p.hom ≫ f'
⊢ (f' ≫ q.inv) ≫ q.hom = (p.inv ≫ f) ≫ q.hom
state_after: no goals
tactic: simp [w]
Theorem: Profinite.NobelingProof.list_prod_apply
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x : ↑C
l : List (LocallyConstant ↑C ℤ)
⊢ l.prod x = (List.map (⇑(LocallyConstant.evalMonoidHom x)) l).prod
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x : ↑C
l : List (LocallyConstant ↑C ℤ)
⊢ l.prod x = (LocallyConstant.evalMonoidHom x) l.prod
tactic: rw [← map_list_prod (LocallyConstant.evalMonoidHom x) l]
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x : ↑C
l : List (LocallyConstant ↑C ℤ)
⊢ l.prod x = (LocallyConstant.evalMonoidHom x) l.prod
state_after: no goals
tactic: rfl
Theorem: RingHom.ker_isRadical_iff_reduced_of_surjective
File: Mathlib/RingTheory/Nilpotent/Lemmas.lean

Proof steps:
state_before: R : Type u_1
S✝ : Type u_2
x y : R
S : Type u_3
F : Type u_4
inst✝³ : CommSemiring R
inst✝² : CommRing S
inst✝¹ : FunLike F R S
inst✝ : RingHomClass F R S
f : F
hf : Surjective ⇑f
⊢ (ker f).IsRadical ↔ IsReduced S
state_after: R : Type u_1
S✝ : Type u_2
x y : R
S : Type u_3
F : Type u_4
inst✝³ : CommSemiring R
inst✝² : CommRing S
inst✝¹ : FunLike F R S
inst✝ : RingHomClass F R S
f : F
hf : Surjective ⇑f
⊢ (ker f).IsRadical ↔ ∀ (x : R), (∃ n, x ^ n ∈ ker f) → x ∈ ker f
tactic: simp_rw [isReduced_iff, hf.forall, IsNilpotent, ← map_pow, ← RingHom.mem_ker]
state_before: R : Type u_1
S✝ : Type u_2
x y : R
S : Type u_3
F : Type u_4
inst✝³ : CommSemiring R
inst✝² : CommRing S
inst✝¹ : FunLike F R S
inst✝ : RingHomClass F R S
f : F
hf : Surjective ⇑f
⊢ (ker f).IsRadical ↔ ∀ (x : R), (∃ n, x ^ n ∈ ker f) → x ∈ ker f
state_after: no goals
tactic: rfl