ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LinearMap.ker_eq_bot_iff_range_eq_top_of_finrank_eq_finrank
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
V₂ : Type v'
inst✝³ : AddCommGroup V₂
inst✝² : Module K V₂
inst✝¹ : FiniteDimensional K V
inst✝ : FiniteDimensional K V₂
H : finrank K V = finrank K V₂
f : V →ₗ[K] V₂
⊢ ker f = ⊥ ↔ range f = ⊤
state_after: no goals
tactic: rw [range_eq_top, ker_eq_bot, injective_iff_surjective_of_finrank_eq_finrank H]
Theorem: Magma.AssocQuotient.lift_symm_apply
File: Mathlib/Algebra/Free.lean

Proof steps:
state_before: α : Type u
inst✝¹ : Mul α
β : Type v
inst✝ : Semigroup β
f✝ f : α →ₙ* β
x : AssocQuotient α
⊢ ∀ (a b : α), AssocRel α a b → f a = f b
state_after: no goals
tactic: rintro a b (⟨c, d, e⟩ | ⟨c, d, e, f⟩) <;> simp only [map_mul, mul_assoc]
Theorem: Submodule.one_le_finrank_iff
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M'
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
inst✝⁵ : Module R M₁
inst✝⁴ : Nontrivial R
inst✝³ : NoZeroSMulDivisors R M
inst✝² : StrongRankCondition R
inst✝¹ : NoZeroSMulDivisors R M
S : Submodule R M
inst✝ : Module.Finite R ↥S
⊢ 1 ≤ finrank R ↥S ↔ S ≠ ⊥
state_after: no goals
tactic: simp [← not_iff_not]
Theorem: Nat.odd_add
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
m n : ℕ
⊢ Odd (m + n) ↔ (Odd m ↔ Even n)
state_after: no goals
tactic: rw [odd_iff_not_even, even_add, not_iff, odd_iff_not_even]
Theorem: Nat.dvd_right_iff_eq
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
h : m = n✝
n : ℕ
⊢ m ∣ n ↔ n✝ ∣ n
state_after: no goals
tactic: rw [h]
Theorem: SimpleGraph.Walk.length_darts
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
⊢ p.darts.length = p.length
state_after: no goals
tactic: induction p <;> simp [*]
Theorem: Finsupp.mul_prod_erase
File: Mathlib/Algebra/BigOperators/Finsupp.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝² : Zero M
inst✝¹ : Zero M'
inst✝ : CommMonoid N
f : α →₀ M
y : α
g : α → M → N
hyf : y ∈ f.support
⊢ g y (f y) * (erase y f).prod g = f.prod g
state_after: no goals
tactic: classical
    rw [Finsupp.prod, Finsupp.prod, ← Finset.mul_prod_erase _ _ hyf, Finsupp.support_erase,
      Finset.prod_congr rfl]
    intro h hx
    rw [Finsupp.erase_ne (ne_of_mem_erase hx)]
Theorem: smul_eq_zero_iff_right
File: Mathlib/Algebra/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
k : Type u_3
S : Type u_4
M : Type u_5
M₂ : Type u_6
M₃ : Type u_7
ι : Type u_8
inst✝³ : Zero R
inst✝² : Zero M
inst✝¹ : SMulWithZero R M
inst✝ : NoZeroSMulDivisors R M
c : R
x : M
hc : c ≠ 0
⊢ c • x = 0 ↔ x = 0
state_after: no goals
tactic: simp [hc]
Theorem: ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.evalAt_apply
File: Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean

Proof steps:
state_before: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
⊢ ∀ (x y : ↑X), (fun x => s • g x) (x + y) = (fun x => s • g x) x + (fun x => s • g x) y
state_after: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
x✝ y✝ : ↑X
⊢ (fun x => s • g x) (x✝ + y✝) = (fun x => s • g x) x✝ + (fun x => s • g x) y✝
tactic: intros
state_before: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
x✝ y✝ : ↑X
⊢ (fun x => s • g x) (x✝ + y✝) = (fun x => s • g x) x✝ + (fun x => s • g x) y✝
state_after: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
x✝ y✝ : ↑X
⊢ s • g (x✝ + y✝) = s • g x✝ + s • g y✝
tactic: dsimp only
state_before: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
x✝ y✝ : ↑X
⊢ s • g (x✝ + y✝) = s • g x✝ + s • g y✝
state_after: no goals
tactic: rw [map_add,smul_add]
state_before: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
⊢ ∀ (m : R) (x : ↑X),
    { toFun := fun x => s • g x, map_add' := ⋯ }.toFun (m • x) =
      (RingHom.id R) m • { toFun := fun x => s • g x, map_add' := ⋯ }.toFun x
state_after: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
r : R
x : ↑X
⊢ { toFun := fun x => s • g x, map_add' := ⋯ }.toFun (r • x) =
    (RingHom.id R) r • { toFun := fun x => s • g x, map_add' := ⋯ }.toFun x
tactic: intros r x
state_before: R✝ : Type u₁
S✝ : Type u₂
inst✝³ : CommRing R✝
inst✝² : CommRing S✝
f✝ : R✝ →+* S✝
R : Type u₁
S : Type u₂
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
X : ModuleCat R
Y : ModuleCat S
s : S
g : X ⟶ (restrictScalars f).obj Y
r : R
x : ↑X
⊢ { toFun := fun x => s • g x, map_add' := ⋯ }.toFun (r • x) =
    (RingHom.id R) r • { toFun := fun x => s • g x, map_add' := ⋯ }.toFun x
state_after: no goals
tactic: rw [AddHom.toFun_eq_coe, AddHom.coe_mk, RingHom.id_apply,
        LinearMap.map_smul, smul_comm r s (g x : Y)]
Theorem: MvPolynomial.optionEquivRight_apply
File: Mathlib/Algebra/MvPolynomial/Equiv.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
⊢ (aeval fun o => o.elim (C Polynomial.X) X).comp (aevalTower (Polynomial.aeval (X none)) fun i => X (Option.some i)) =
    AlgHom.id R (MvPolynomial S₁ R[X])
state_after: no goals
tactic: ext : 2 <;>
        simp only [MvPolynomial.algebraMap_eq, Option.elim, AlgHom.coe_comp, AlgHom.id_comp,
          IsScalarTower.coe_toAlgHom', comp_apply, aevalTower_C, Polynomial.aeval_X, aeval_X,
          Option.elim', aevalTower_X, AlgHom.coe_id, id, eq_self_iff_true, imp_true_iff]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
⊢ (aevalTower (Polynomial.aeval (X none)) fun i => X (Option.some i)).comp (aeval fun o => o.elim (C Polynomial.X) X) =
    AlgHom.id R (MvPolynomial (Option S₁) R)
state_after: no goals
tactic: ext ⟨i⟩ : 2 <;>
        simp only [Option.elim, AlgHom.coe_comp, comp_apply, aeval_X, aevalTower_C,
          Polynomial.aeval_X, AlgHom.coe_id, id, aevalTower_X]
Theorem: Finset.noncommProd_congr
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s₁ s₂ : Finset α
f g : α → β
h₁ : s₁ = s₂
h₂ : ∀ x ∈ s₂, f x = g x
comm : (↑s₁).Pairwise fun a b => Commute (f a) (f b)
x : α
hx : x ∈ ↑s₂
y : α
hy : y ∈ ↑s₂
h : x ≠ y
⊢ (fun a b => Commute (g a) (g b)) x y
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s₁ s₂ : Finset α
f g : α → β
h₁ : s₁ = s₂
h₂ : ∀ x ∈ s₂, f x = g x
comm : (↑s₁).Pairwise fun a b => Commute (f a) (f b)
x : α
hx : x ∈ ↑s₂
y : α
hy : y ∈ ↑s₂
h : x ≠ y
⊢ Commute (g x) (g y)
tactic: dsimp only
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s₁ s₂ : Finset α
f g : α → β
h₁ : s₁ = s₂
h₂ : ∀ x ∈ s₂, f x = g x
comm : (↑s₁).Pairwise fun a b => Commute (f a) (f b)
x : α
hx : x ∈ ↑s₂
y : α
hy : y ∈ ↑s₂
h : x ≠ y
⊢ Commute (g x) (g y)
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s₁ s₂ : Finset α
f g : α → β
h₁ : s₁ = s₂
h₂ : ∀ x ∈ s₂, f x = g x
comm : (↑s₁).Pairwise fun a b => Commute (f a) (f b)
x : α
hx : x ∈ ↑s₂
y : α
hy : y ∈ ↑s₂
h : x ≠ y
⊢ Commute (f x) (f y)
tactic: rw [← h₂ _ hx, ← h₂ _ hy]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s₁ s₂ : Finset α
f g : α → β
h₁ : s₁ = s₂
h₂ : ∀ x ∈ s₂, f x = g x
comm : (↑s₁).Pairwise fun a b => Commute (f a) (f b)
x : α
hx : x ∈ ↑s₂
y : α
hy : y ∈ ↑s₂
h : x ≠ y
⊢ Commute (f x) (f y)
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s₁ : Finset α
f g : α → β
comm : (↑s₁).Pairwise fun a b => Commute (f a) (f b)
x y : α
h : x ≠ y
h₂ : ∀ x ∈ s₁, f x = g x
hx : x ∈ ↑s₁
hy : y ∈ ↑s₁
⊢ Commute (f x) (f y)
tactic: subst h₁
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s₁ : Finset α
f g : α → β
comm : (↑s₁).Pairwise fun a b => Commute (f a) (f b)
x y : α
h : x ≠ y
h₂ : ∀ x ∈ s₁, f x = g x
hx : x ∈ ↑s₁
hy : y ∈ ↑s₁
⊢ Commute (f x) (f y)
state_after: no goals
tactic: exact comm hx hy h
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s₁ s₂ : Finset α
f g : α → β
h₁ : s₁ = s₂
h₂ : ∀ x ∈ s₂, f x = g x
comm : (↑s₁).Pairwise fun a b => Commute (f a) (f b)
⊢ s₁.noncommProd f comm = s₂.noncommProd g ⋯
state_after: no goals
tactic: simp_rw [noncommProd, Multiset.map_congr (congr_arg _ h₁) h₂]
Theorem: Finset.mem_neg_vadd_finset_iff
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ b ∈ a⁻¹ • s ↔ a • b ∈ s
state_after: no goals
tactic: rw [← smul_mem_smul_finset_iff a, smul_inv_smul]
Theorem: FreeGroup.Red.Step.length
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ L1 L2 : List (α × Bool)
x : α
b : Bool
⊢ (L1 ++ L2).length + 2 = (L1 ++ (x, b) :: (x, !b) :: L2).length
state_after: α : Type u
L L₁ L₂ L₃ L₄ L1 L2 : List (α × Bool)
x : α
b : Bool
⊢ L1.length + L2.length + 2 = L1.length + ((x, b) :: (x, !b) :: L2).length
tactic: rw [List.length_append, List.length_append]
state_before: α : Type u
L L₁ L₂ L₃ L₄ L1 L2 : List (α × Bool)
x : α
b : Bool
⊢ L1.length + L2.length + 2 = L1.length + ((x, b) :: (x, !b) :: L2).length
state_after: no goals
tactic: rfl
Theorem: CompleteLattice.WellFounded.finite_ne_bot_of_independent
File: Mathlib/Order/CompactlyGenerated/Basic.lean

Proof steps:
state_before: ι✝ : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι✝ → α
hwf : WellFounded fun x x_1 => x > x_1
ι : Type u_3
t : ι → α
ht : Independent t
⊢ {i | t i ≠ ⊥}.Finite
state_after: ι✝ : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι✝ → α
hwf : WellFounded fun x x_1 => x > x_1
ι : Type u_3
t : ι → α
ht : Independent t
⊢ (range t).Finite
tactic: refine Finite.of_finite_image (Finite.subset ?_ (image_subset_range t _)) ht.injOn
state_before: ι✝ : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι✝ → α
hwf : WellFounded fun x x_1 => x > x_1
ι : Type u_3
t : ι → α
ht : Independent t
⊢ (range t).Finite
state_after: no goals
tactic: exact WellFounded.finite_of_setIndependent hwf ht.setIndependent_range
Theorem: QuaternionAlgebra.mul_star_eq_coe
File: Mathlib/Algebra/Quaternion.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ a * star a = ↑(a * star a).re
state_after: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ star a * a = ↑(star a * a).re
tactic: rw [← star_comm_self']
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ star a * a = ↑(star a * a).re
state_after: no goals
tactic: exact a.star_mul_eq_coe
Theorem: Finset.Ioc_subset_Ioc
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
ha : a₂ ≤ a₁
hb : b₁ ≤ b₂
⊢ Ioc a₁ b₁ ⊆ Ioc a₂ b₂
state_after: no goals
tactic: simpa [← coe_subset] using Set.Ioc_subset_Ioc ha hb
Theorem: MeasureTheory.Integrable.toL1_coeFn
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : ↥(Lp β 1 μ)
hf : Integrable (↑↑f) μ
⊢ toL1 (↑↑f) hf = f
state_after: no goals
tactic: simp [Integrable.toL1]
Theorem: Equiv.toPartialEquivOfImageEq_apply
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e' : PartialEquiv β γ
e : α ≃ β
s : Set α
t : Set β
h : ⇑e '' s = t
x : β
hx : x ∈ t
⊢ e.symm x ∈ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e' : PartialEquiv β γ
e : α ≃ β
s : Set α
x : β
hx : x ∈ ⇑e '' s
⊢ e.symm x ∈ s
tactic: subst t
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e' : PartialEquiv β γ
e : α ≃ β
s : Set α
x : β
hx : x ∈ ⇑e '' s
⊢ e.symm x ∈ s
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e' : PartialEquiv β γ
e : α ≃ β
s : Set α
x : α
hx : x ∈ s
⊢ e.symm (e x) ∈ s
tactic: rcases hx with ⟨x, hx, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e' : PartialEquiv β γ
e : α ≃ β
s : Set α
x : α
hx : x ∈ s
⊢ e.symm (e x) ∈ s
state_after: no goals
tactic: rwa [e.symm_apply_apply]
Theorem: PMF.bernoulli_expectation
File: Mathlib/Probability/ProbabilityMassFunction/Integrals.lean

Proof steps:
state_before: p : ℝ≥0∞
h : p ≤ 1
⊢ ∫ (b : Bool), bif b then 1 else 0 ∂(bernoulli p h).toMeasure = p.toReal
state_after: no goals
tactic: simp [integral_eq_sum]
Theorem: Set.diff_singleton_subset_iff
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u : Set α
x : α
s t : Set α
⊢ s \ {x} ⊆ t ↔ s ⊆ insert x t
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u : Set α
x : α
s t : Set α
⊢ s \ {x} ⊆ t ↔ s ⊆ {x} ∪ t
tactic: rw [← union_singleton, union_comm]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u : Set α
x : α
s t : Set α
⊢ s \ {x} ⊆ t ↔ s ⊆ {x} ∪ t
state_after: no goals
tactic: apply diff_subset_iff
Theorem: Polynomial.Monic.ne_zero
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
R : Type u_2
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p : R[X]
hp : p.Monic
⊢ p ≠ 0
state_after: R✝ : Type u
S : Type v
a b c d : R✝
n m : ℕ
inst✝² : Semiring R✝
p✝ p q : R✝[X]
ι : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : Nontrivial R
hp : Monic 0
⊢ False
tactic: rintro rfl
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
R : Type u_2
inst✝¹ : Semiring R
inst✝ : Nontrivial R
hp : Monic 0
⊢ False
state_after: no goals
tactic: simp [Monic] at hp
Theorem: equicontinuousWithinAt_univ
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
x₀ : X
⊢ EquicontinuousWithinAt F univ x₀ ↔ EquicontinuousAt F x₀
state_after: no goals
tactic: rw [EquicontinuousWithinAt, EquicontinuousAt, nhdsWithin_univ]
Theorem: ProbabilityTheory.truncation_eq_of_nonneg
File: Mathlib/Probability/StrongLaw.lean

Proof steps:
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
h : ∀ (x : α), 0 ≤ f x
⊢ truncation f A = (Set.Ioc 0 A).indicator id ∘ f
state_after: case h
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
h : ∀ (x : α), 0 ≤ f x
x : α
⊢ truncation f A x = ((Set.Ioc 0 A).indicator id ∘ f) x
tactic: ext x
state_before: case h
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
h : ∀ (x : α), 0 ≤ f x
x : α
⊢ truncation f A x = ((Set.Ioc 0 A).indicator id ∘ f) x
state_after: case h.inl
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
h : ∀ (x : α), 0 ≤ f x
x : α
hx : 0 < f x
⊢ truncation f A x = ((Set.Ioc 0 A).indicator id ∘ f) x

case h.inr
α : Type u_1
m : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
A : ℝ
h : ∀ (x : α), 0 ≤ f x
x : α
hx : 0 = f x
⊢ truncation f A x = ((Set.Ioc 0 A).indicator id ∘ f) x
tactic: rcases (h x).lt_or_eq with (hx | hx)
Theorem: SemiconjBy.units_inv_symm_left
File: Mathlib/Algebra/Group/Semiconj/Units.lean

Proof steps:
state_before: M : Type u_1
G : Type u_2
inst✝ : Monoid M
a : Mˣ
x y : M
h : SemiconjBy (↑a) x y
⊢ ↑a⁻¹ * y = ↑a⁻¹ * (y * ↑a * ↑a⁻¹)
state_after: no goals
tactic: rw [Units.mul_inv_cancel_right]
state_before: M : Type u_1
G : Type u_2
inst✝ : Monoid M
a : Mˣ
x y : M
h : SemiconjBy (↑a) x y
⊢ ↑a⁻¹ * (y * ↑a * ↑a⁻¹) = x * ↑a⁻¹
state_after: no goals
tactic: rw [← h.eq, ← mul_assoc, Units.inv_mul_cancel_left]
Theorem: Filter.frequently_inf_principal
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
s : Set α
p : α → Prop
⊢ (∃ᶠ (x : α) in f ⊓ 𝓟 s, p x) ↔ ∃ᶠ (x : α) in f, x ∈ s ∧ p x
state_after: no goals
tactic: simp only [Filter.Frequently, eventually_inf_principal, not_and]
Theorem: BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
y : ι → ℝ
h₁ : J ∈ split I i x
h₂ : y ∈ J
h₃ : y i ≤ x
⊢ ↑J = ↑I ∩ {y | y i ≤ x}
state_after: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
y : ι → ℝ
h₁ : J ∈ split I i x
h₂ : y ∈ J
h₃ : y i ≤ x
H : ↑J = ↑I ∩ {y | x < y i}
⊢ False
tactic: refine (mem_split_iff'.1 h₁).resolve_right fun H => ?_
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
y : ι → ℝ
h₁ : J ∈ split I i x
h₂ : y ∈ J
h₃ : y i ≤ x
H : ↑J = ↑I ∩ {y | x < y i}
⊢ False
state_after: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
y : ι → ℝ
h₁ : J ∈ split I i x
h₂ : y ∈ ↑I ∩ {y | x < y i}
h₃ : y i ≤ x
H : ↑J = ↑I ∩ {y | x < y i}
⊢ False
tactic: rw [← Box.mem_coe, H] at h₂
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
y : ι → ℝ
h₁ : J ∈ split I i x
h₂ : y ∈ ↑I ∩ {y | x < y i}
h₃ : y i ≤ x
H : ↑J = ↑I ∩ {y | x < y i}
⊢ False
state_after: no goals
tactic: exact h₃.not_lt h₂.2
Theorem: Matrix.conjTranspose_eq_zero
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
M : Matrix m n α
⊢ Mᴴ = 0 ↔ M = 0
state_after: no goals
tactic: rw [← conjTranspose_inj (A := M), conjTranspose_zero]
Theorem: Nat.range_of_succ
File: Mathlib/Data/Nat/Set.lean

Proof steps:
state_before: α : Type u_1
f : ℕ → α
⊢ {f 0} ∪ range (f ∘ succ) = range f
state_after: no goals
tactic: rw [← image_singleton, range_comp, ← image_union, zero_union_range_succ, image_univ]
Theorem: AlgebraicGeometry.AffineTargetMorphismProperty.arrow_mk_iso_iff
File: Mathlib/AlgebraicGeometry/Morphisms/Basic.lean

Proof steps:
state_before: P : AffineTargetMorphismProperty
inst✝ : P.toProperty.RespectsIso
X Y X' Y' : Scheme
f : X ⟶ Y
f' : X' ⟶ Y'
e : Arrow.mk f ≅ Arrow.mk f'
h : IsAffine Y
⊢ P f ↔ P f'
state_after: no goals
tactic: rw [← P.toProperty_apply, ← P.toProperty_apply, P.toProperty.arrow_mk_iso_iff e]
Theorem: CategoryTheory.NonPreadditiveAbelian.add_comm
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ a + b = b + a
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ a - -b = b + a
tactic: rw [add_def]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ a - -b = b + a
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ - -a - -b = b + a
tactic: conv_lhs => rw [← neg_neg a]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ - -a - -b = b + a
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ 0 - 0 - (0 - a - b) = b + a
tactic: rw [neg_def, neg_def, neg_def, sub_sub_sub]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ 0 - 0 - (0 - a - b) = b + a
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ 0 - 0 - (-b - a) = b + a
tactic: conv_lhs =>
    congr
    next => skip
    rw [← neg_def, neg_sub]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ 0 - 0 - (-b - a) = b + a
state_after: no goals
tactic: rw [sub_sub_sub, add_def, ← neg_def, neg_neg b, neg_def]
Theorem: AddCommGroup.modEq_zero
File: Mathlib/Algebra/ModEq.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ a ≡ b [PMOD 0] ↔ a = b
state_after: no goals
tactic: simp [ModEq, sub_eq_zero, eq_comm]
Theorem: monovary_inv_left
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : OrderedCommGroup α
inst✝ : OrderedCommGroup β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
⊢ Monovary f⁻¹ g ↔ Antivary f g
state_after: no goals
tactic: simp [Monovary, Antivary]