ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: TrivSqZeroExt.inv_inl
File: Mathlib/Algebra/TrivSqZeroExt.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
r : R
⊢ (inl r)⁻¹ = inl r⁻¹
state_after: case h1
R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
r : R
⊢ (inl r)⁻¹.fst = (inl r⁻¹).fst

case h2
R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
r : R
⊢ (inl r)⁻¹.snd = (inl r⁻¹).snd
tactic: ext
Theorem: Even.neg_one_zpow
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : DivisionMonoid α
inst✝ : HasDistribNeg α
a : α
n : ℤ
h : Even n
⊢ (-1) ^ n = 1
state_after: no goals
tactic: rw [h.neg_zpow, one_zpow]
Theorem: Real.abs_le_sqrt
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x y : ℝ
h : x ^ 2 ≤ y
⊢ |x| ≤ √y
state_after: x y : ℝ
h : x ^ 2 ≤ y
⊢ √(x ^ 2) ≤ √y
tactic: rw [← sqrt_sq_eq_abs]
state_before: x y : ℝ
h : x ^ 2 ≤ y
⊢ √(x ^ 2) ≤ √y
state_after: no goals
tactic: exact sqrt_le_sqrt h
Theorem: isMulFreimanIso_empty
File: Mathlib/Combinatorics/Additive/FreimanHom.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
s t : Multiset α
hs : ∀ ⦃x : α⦄, x ∈ s → x ∈ ∅
ht : ∀ ⦃x : α⦄, x ∈ t → x ∈ ∅
⊢ card s = n → card t = n → ((map f s).prod = (map f t).prod ↔ s.prod = t.prod)
state_after: no goals
tactic: simp [eq_zero_of_forall_not_mem hs, eq_zero_of_forall_not_mem ht]
Theorem: sq_sum_le_card_mul_sum_sq
File: Mathlib/Algebra/Order/Chebyshev.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
s : Finset ι
σ : Perm ι
f g : ι → α
⊢ (∑ i ∈ s, f i) ^ 2 ≤ ↑s.card * ∑ i ∈ s, f i ^ 2
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
s : Finset ι
σ : Perm ι
f g : ι → α
⊢ (∑ i ∈ s, f i) * ∑ i ∈ s, f i ≤ ↑s.card * ∑ x ∈ s, f x * f x
tactic: simp_rw [sq]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
s : Finset ι
σ : Perm ι
f g : ι → α
⊢ (∑ i ∈ s, f i) * ∑ i ∈ s, f i ≤ ↑s.card * ∑ x ∈ s, f x * f x
state_after: no goals
tactic: exact (monovaryOn_self _ _).sum_mul_sum_le_card_mul_sum
Theorem: Finset.isUnit_iff_singleton
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✝⁴ : DecidableEq β
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
s t : Finset α
a b : α
⊢ IsUnit s ↔ ∃ a, s = {a}
state_after: no goals
tactic: simp only [isUnit_iff, Group.isUnit, and_true_iff]
Theorem: Int.bitwise_bit
File: Mathlib/Data/Int/Bitwise.lean

Proof steps:
state_before: f : Bool → Bool → Bool
a : Bool
m : ℤ
b : Bool
n : ℤ
⊢ bitwise f (bit a m) (bit b n) = bit (f a b) (bitwise f m n)
state_after: case ofNat.ofNat
f : Bool → Bool → Bool
a b : Bool
m n : ℕ
⊢ (bif f false false then -[Nat.bitwise (fun x y => !f x y) (Nat.bit a m) (Nat.bit b n)+1]
    else ↑(Nat.bitwise f (Nat.bit a m) (Nat.bit b n))) =
    bit (f a b) (bif f false false then -[Nat.bitwise (fun x y => !f x y) m n+1] else ↑(Nat.bitwise f m n))

case ofNat.negSucc
f : Bool → Bool → Bool
a b : Bool
m n : ℕ
⊢ (bif f false true then -[Nat.bitwise (fun x y => !f x !y) (Nat.bit a m) (Nat.bit (!b) n)+1]
    else ↑(Nat.bitwise (fun x y => f x !y) (Nat.bit a m) (Nat.bit (!b) n))) =
    bit (f a b)
      (bif f false true then -[Nat.bitwise (fun x y => !f x !y) m n+1] else ↑(Nat.bitwise (fun x y => f x !y) m n))

case negSucc.ofNat
f : Bool → Bool → Bool
a b : Bool
m n : ℕ
⊢ (bif f true false then -[Nat.bitwise (fun x y => !f (!x) y) (Nat.bit (!a) m) (Nat.bit b n)+1]
    else ↑(Nat.bitwise (fun x y => f (!x) y) (Nat.bit (!a) m) (Nat.bit b n))) =
    bit (f a b)
      (bif f true false then -[Nat.bitwise (fun x y => !f (!x) y) m n+1] else ↑(Nat.bitwise (fun x y => f (!x) y) m n))

case negSucc.negSucc
f : Bool → Bool → Bool
a b : Bool
m n : ℕ
⊢ (bif f true true then -[Nat.bitwise (fun x y => !f (!x) !y) (Nat.bit (!a) m) (Nat.bit (!b) n)+1]
    else ↑(Nat.bitwise (fun x y => f (!x) !y) (Nat.bit (!a) m) (Nat.bit (!b) n))) =
    bit (f a b)
      (bif f true true then -[Nat.bitwise (fun x y => !f (!x) !y) m n+1] else ↑(Nat.bitwise (fun x y => f (!x) !y) m n))
tactic: cases' m with m m <;> cases' n with n n <;>
  simp [bitwise, ofNat_eq_coe, bit_coe_nat, natBitwise, Bool.not_false, Bool.not_eq_false',
    bit_negSucc]
Theorem: List.Ico.filter_le_of_le_bot
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ decide (l ≤ k) = true
state_after: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ l ≤ k
tactic: rw [decide_eq_true_eq]
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ l ≤ k
state_after: no goals
tactic: exact le_trans hln (mem.1 hk).1
Theorem: NNReal.sSup_of_not_bddAbove
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: ι : Sort u_1
f : ι → ℝ≥0
s : Set ℝ≥0
hs : ¬BddAbove s
⊢ sSup s = 0
state_after: ι : Sort u_1
f : ι → ℝ≥0
s : Set ℝ≥0
hs : ¬BddAbove (toReal '' s)
⊢ sSup s = 0
tactic: rw [← bddAbove_coe] at hs
state_before: ι : Sort u_1
f : ι → ℝ≥0
s : Set ℝ≥0
hs : ¬BddAbove (toReal '' s)
⊢ sSup s = 0
state_after: ι : Sort u_1
f : ι → ℝ≥0
s : Set ℝ≥0
hs : ¬BddAbove (toReal '' s)
⊢ sSup (toReal '' s) = 0
tactic: rw [← coe_inj, coe_sSup, NNReal.coe_zero]
state_before: ι : Sort u_1
f : ι → ℝ≥0
s : Set ℝ≥0
hs : ¬BddAbove (toReal '' s)
⊢ sSup (toReal '' s) = 0
state_after: no goals
tactic: exact sSup_of_not_bddAbove hs
Theorem: Filter.filter_injOn_Iic_iff_injOn
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Filter α
G : Filter β
s : Set α
m : α → β
⊢ InjOn (map m) (Iic (𝓟 s)) ↔ InjOn m s
state_after: case refine_1
α : Type u_1
β : Type u_2
F : Filter α
G : Filter β
s : Set α
m : α → β
hm : InjOn (map m) (Iic (𝓟 s))
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : m x = m y
⊢ x = y

case refine_2
α : Type u_1
β : Type u_2
F✝ : Filter α
G✝ : Filter β
s : Set α
m : α → β
hm : InjOn m s
F : Filter α
hF : F ∈ Iic (𝓟 s)
G : Filter α
hG : G ∈ Iic (𝓟 s)
⊢ map m F = map m G → F = G
tactic: refine ⟨fun hm x hx y hy hxy ↦ ?_, fun hm F hF G hG ↦ ?_⟩
Theorem: Polynomial.Chebyshev.one_sub_X_sq_mul_derivative_T_eq_poly_in_T
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
⊢ (1 - X ^ 2) * derivative (T R (n + 1)) = (↑n + 1) * (T R n - X * T R (n + 1))
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
H₁ : (1 - X ^ 2) * U R n = X * T R (n + 1) - T R (n + 2)
⊢ (1 - X ^ 2) * derivative (T R (n + 1)) = (↑n + 1) * (T R n - X * T R (n + 1))
tactic: have H₁ := one_sub_X_sq_mul_U_eq_pol_in_T R n
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
H₁ : (1 - X ^ 2) * U R n = X * T R (n + 1) - T R (n + 2)
⊢ (1 - X ^ 2) * derivative (T R (n + 1)) = (↑n + 1) * (T R n - X * T R (n + 1))
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
H₁ : (1 - X ^ 2) * U R n = X * T R (n + 1) - T R (n + 2)
H₂ : derivative (T R (n + 1)) = ↑(n + 1) * U R (n + 1 - 1)
⊢ (1 - X ^ 2) * derivative (T R (n + 1)) = (↑n + 1) * (T R n - X * T R (n + 1))
tactic: have H₂ := T_derivative_eq_U (R := R) (n + 1)
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
H₁ : (1 - X ^ 2) * U R n = X * T R (n + 1) - T R (n + 2)
H₂ : derivative (T R (n + 1)) = ↑(n + 1) * U R (n + 1 - 1)
⊢ (1 - X ^ 2) * derivative (T R (n + 1)) = (↑n + 1) * (T R n - X * T R (n + 1))
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
H₁ : (1 - X ^ 2) * U R n = X * T R (n + 1) - T R (n + 2)
H₂ : derivative (T R (n + 1)) = ↑(n + 1) * U R (n + 1 - 1)
h₁ : T R (n + 2) = 2 * X * T R (n + 1) - T R n
⊢ (1 - X ^ 2) * derivative (T R (n + 1)) = (↑n + 1) * (T R n - X * T R (n + 1))
tactic: have h₁ := T_add_two R n
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
H₁ : (1 - X ^ 2) * U R n = X * T R (n + 1) - T R (n + 2)
H₂ : derivative (T R (n + 1)) = ↑(n + 1) * U R (n + 1 - 1)
h₁ : T R (n + 2) = 2 * X * T R (n + 1) - T R n
⊢ (1 - X ^ 2) * derivative (T R (n + 1)) = (↑n + 1) * (T R n - X * T R (n + 1))
state_after: no goals
tactic: linear_combination (norm := (push_cast; ring_nf))
    (-n - 1) * h₁ + (-(X : R[X]) ^ 2 + 1) * H₂ + (n + 1) * H₁
Theorem: OrderIso.complementedLattice_iff
File: Mathlib/Order/Hom/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f✝ f : α ≃o β
⊢ ComplementedLattice α → ComplementedLattice β
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f✝ f : α ≃o β
a✝ : ComplementedLattice α
⊢ ComplementedLattice β
tactic: intro
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f✝ f : α ≃o β
a✝ : ComplementedLattice α
⊢ ComplementedLattice β
state_after: no goals
tactic: exact f.complementedLattice
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f✝ f : α ≃o β
⊢ ComplementedLattice β → ComplementedLattice α
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f✝ f : α ≃o β
a✝ : ComplementedLattice β
⊢ ComplementedLattice α
tactic: intro
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f✝ f : α ≃o β
a✝ : ComplementedLattice β
⊢ ComplementedLattice α
state_after: no goals
tactic: exact f.symm.complementedLattice
Theorem: CategoryTheory.factorThruImage_comp_imageUnopOp_inv
File: Mathlib/CategoryTheory/Abelian/Opposite.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ factorThruImage g ≫ (imageUnopOp g).inv = (image.ι g.unop).op
state_after: no goals
tactic: rw [Iso.comp_inv_eq, image_ι_op_comp_imageUnopOp_hom]
Theorem: Int.sqrt_eq
File: Mathlib/Data/Int/Sqrt.lean

Proof steps:
state_before: n : ℤ
⊢ sqrt (n * n) = ↑n.natAbs
state_after: no goals
tactic: rw [sqrt, ← natAbs_mul_self, toNat_natCast, Nat.sqrt_eq]
Theorem: continuousMul_of_comm_of_nhds_one
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M✝ : Type u_3
N : Type u_4
X : Type u_5
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace M✝
inst✝³ : Mul M✝
inst✝² : ContinuousMul M✝
M : Type u
inst✝¹ : CommMonoid M
inst✝ : TopologicalSpace M
hmul : Tendsto (uncurry fun x x_1 => x * x_1) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
hleft : ∀ (x₀ : M), 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1)
⊢ ContinuousMul M
state_after: ι : Type u_1
α : Type u_2
M✝ : Type u_3
N : Type u_4
X : Type u_5
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace M✝
inst✝³ : Mul M✝
inst✝² : ContinuousMul M✝
M : Type u
inst✝¹ : CommMonoid M
inst✝ : TopologicalSpace M
hmul : Tendsto (uncurry fun x x_1 => x * x_1) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
hleft : ∀ (x₀ : M), 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1)
⊢ ∀ (x₀ : M), 𝓝 x₀ = map (fun x => x * x₀) (𝓝 1)
tactic: apply ContinuousMul.of_nhds_one hmul hleft
state_before: ι : Type u_1
α : Type u_2
M✝ : Type u_3
N : Type u_4
X : Type u_5
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace M✝
inst✝³ : Mul M✝
inst✝² : ContinuousMul M✝
M : Type u
inst✝¹ : CommMonoid M
inst✝ : TopologicalSpace M
hmul : Tendsto (uncurry fun x x_1 => x * x_1) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
hleft : ∀ (x₀ : M), 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1)
⊢ ∀ (x₀ : M), 𝓝 x₀ = map (fun x => x * x₀) (𝓝 1)
state_after: ι : Type u_1
α : Type u_2
M✝ : Type u_3
N : Type u_4
X : Type u_5
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace M✝
inst✝³ : Mul M✝
inst✝² : ContinuousMul M✝
M : Type u
inst✝¹ : CommMonoid M
inst✝ : TopologicalSpace M
hmul : Tendsto (uncurry fun x x_1 => x * x_1) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
hleft : ∀ (x₀ : M), 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1)
x₀ : M
⊢ 𝓝 x₀ = map (fun x => x * x₀) (𝓝 1)
tactic: intro x₀
state_before: ι : Type u_1
α : Type u_2
M✝ : Type u_3
N : Type u_4
X : Type u_5
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace M✝
inst✝³ : Mul M✝
inst✝² : ContinuousMul M✝
M : Type u
inst✝¹ : CommMonoid M
inst✝ : TopologicalSpace M
hmul : Tendsto (uncurry fun x x_1 => x * x_1) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
hleft : ∀ (x₀ : M), 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1)
x₀ : M
⊢ 𝓝 x₀ = map (fun x => x * x₀) (𝓝 1)
state_after: no goals
tactic: simp_rw [mul_comm, hleft x₀]
Theorem: LinearMap.ker_restrict
File: Mathlib/Algebra/Module/Submodule/Ker.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
K : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₃ : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝¹⁴ : Semiring R
inst✝¹³ : Semiring R₂
inst✝¹² : Semiring R₃
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁸ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁷ : Module R M
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝⁴ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_12
inst✝³ : FunLike F M M₂
inst✝² : SemilinearMapClass F τ₁₂ M M₂
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R M₁
p : Submodule R M
q : Submodule R M₁
f : M →ₗ[R] M₁
hf : ∀ x ∈ p, f x ∈ q
⊢ ker (f.restrict hf) = ker (f.domRestrict p)
state_after: no goals
tactic: rw [restrict_eq_codRestrict_domRestrict, ker_codRestrict]
Theorem: gauge_lt_eq
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a✝ : ℝ
absorbs : Absorbent ℝ s
a : ℝ
⊢ {x | gauge s x < a} = ⋃ r ∈ Ioo 0 a, r • s
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a✝ : ℝ
absorbs : Absorbent ℝ s
a : ℝ
x✝ : E
⊢ x✝ ∈ {x | gauge s x < a} ↔ x✝ ∈ ⋃ r ∈ Ioo 0 a, r • s
tactic: ext
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a✝ : ℝ
absorbs : Absorbent ℝ s
a : ℝ
x✝ : E
⊢ x✝ ∈ {x | gauge s x < a} ↔ x✝ ∈ ⋃ r ∈ Ioo 0 a, r • s
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a✝ : ℝ
absorbs : Absorbent ℝ s
a : ℝ
x✝ : E
⊢ gauge s x✝ < a ↔ ∃ i, 0 < i ∧ i < a ∧ x✝ ∈ i • s
tactic: simp_rw [mem_setOf, mem_iUnion, exists_prop, mem_Ioo, and_assoc]
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a✝ : ℝ
absorbs : Absorbent ℝ s
a : ℝ
x✝ : E
⊢ gauge s x✝ < a ↔ ∃ i, 0 < i ∧ i < a ∧ x✝ ∈ i • s
state_after: no goals
tactic: exact
    ⟨exists_lt_of_gauge_lt absorbs, fun ⟨r, hr₀, hr₁, hx⟩ =>
      (gauge_le_of_mem hr₀.le hx).trans_lt hr₁⟩
Theorem: Nat.prod_primeFactorsList
File: Mathlib/Data/Nat/Factors.lean

Proof steps:
state_before: ⊢ 0 ≠ 0 → (primeFactorsList 0).prod = 0
state_after: no goals
tactic: simp
state_before: ⊢ 1 ≠ 0 → (primeFactorsList 1).prod = 1
state_after: no goals
tactic: simp
state_before: k : ℕ
x✝ : k + 2 ≠ 0
m : ℕ := (k + 2).minFac
this : (k + 2) / m < k + 2
⊢ (k + 2).primeFactorsList.prod = k + 2
state_after: k : ℕ
x✝ : k + 2 ≠ 0
m : ℕ := (k + 2).minFac
this : (k + 2) / m < k + 2
h₁ : (k + 2) / m ≠ 0
⊢ (k + 2).primeFactorsList.prod = k + 2
tactic: have h₁ : (k + 2) / m ≠ 0 := fun h => by
        have : (k + 2) = 0 * m := (Nat.div_eq_iff_eq_mul_left (minFac_pos _) (minFac_dvd _)).1 h
        rw [zero_mul] at this; exact (show k + 2 ≠ 0 by simp) this
state_before: k : ℕ
x✝ : k + 2 ≠ 0
m : ℕ := (k + 2).minFac
this : (k + 2) / m < k + 2
h₁ : (k + 2) / m ≠ 0
⊢ (k + 2).primeFactorsList.prod = k + 2
state_after: no goals
tactic: rw [primeFactorsList, List.prod_cons, prod_primeFactorsList h₁,
        Nat.mul_div_cancel' (minFac_dvd _)]
Theorem: WType.cardinal_mk_le_of_le'
File: Mathlib/Data/W/Cardinal.lean

Proof steps:
state_before: α : Type u
β : α → Type v
κ : Cardinal.{max u v}
hκ : (sum fun a => κ ^ lift.{u, v} #(β a)) ≤ κ
⊢ #(WType β) ≤ κ
state_after: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (sum fun a => #γ ^ lift.{u, v} #(β a)) ≤ #γ
⊢ #(WType β) ≤ #γ
tactic: induction' κ using Cardinal.inductionOn with γ
state_before: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (sum fun a => #γ ^ lift.{u, v} #(β a)) ≤ #γ
⊢ #(WType β) ≤ #γ
state_after: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (sum fun a => #γ ^ lift.{max u v, v} #(β a)) ≤ #γ
⊢ #(WType β) ≤ #γ
tactic: simp_rw [← lift_umax.{v, u}] at hκ
state_before: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (sum fun a => #γ ^ lift.{max u v, v} #(β a)) ≤ #γ
⊢ #(WType β) ≤ #γ
state_after: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (sum fun a => lift.{v, max v u} #γ ^ lift.{max u v, v} #(β a)) ≤ #γ
⊢ #(WType β) ≤ #γ
tactic: nth_rewrite 1 [← lift_id'.{v, u} #γ] at hκ
state_before: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (sum fun a => lift.{v, max v u} #γ ^ lift.{max u v, v} #(β a)) ≤ #γ
⊢ #(WType β) ≤ #γ
state_after: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : Nonempty ((i : α) × (β i → γ) ↪ γ)
⊢ #(WType β) ≤ #γ
tactic: simp_rw [← mk_arrow, ← mk_sigma, le_def] at hκ
state_before: case h
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : Nonempty ((i : α) × (β i → γ) ↪ γ)
⊢ #(WType β) ≤ #γ
state_after: case h.intro
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (i : α) × (β i → γ) ↪ γ
⊢ #(WType β) ≤ #γ
tactic: cases' hκ with hκ
state_before: case h.intro
α : Type u
β : α → Type v
γ : Type (max u v)
hκ : (i : α) × (β i → γ) ↪ γ
⊢ #(WType β) ≤ #γ
state_after: no goals
tactic: exact Cardinal.mk_le_of_injective (elim_injective _ hκ.1 hκ.2)
Theorem: CategoryTheory.ShortComplex.leftRightHomologyComparison_fac
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
inst✝ : S.HasHomology
⊢ S.leftRightHomologyComparison = S.leftHomologyIso.hom ≫ S.rightHomologyIso.inv
state_after: no goals
tactic: simpa only [LeftHomologyData.homologyIso_leftHomologyData, Iso.symm_inv,
    RightHomologyData.homologyIso_rightHomologyData, Iso.symm_hom] using
      leftRightHomologyComparison'_fac S.leftHomologyData S.rightHomologyData
Theorem: Multiset.le_ndinter
File: Mathlib/Data/Multiset/FinsetOps.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ s t u : Multiset α
⊢ s ≤ t.ndinter u ↔ s ≤ t ∧ s ⊆ u
state_after: no goals
tactic: simp [ndinter, le_filter, subset_iff]
Theorem: Polynomial.roots_prod
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
ι : Type u_1
f : ι → R[X]
s : Finset ι
⊢ s.prod f ≠ 0 → (s.prod f).roots = s.val.bind fun i => (f i).roots
state_after: case mk
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
ι : Type u_1
f : ι → R[X]
m : Multiset ι
hm : m.Nodup
⊢ { val := m, nodup := hm }.prod f ≠ 0 →
    ({ val := m, nodup := hm }.prod f).roots = { val := m, nodup := hm }.val.bind fun i => (f i).roots
tactic: rcases s with ⟨m, hm⟩
state_before: case mk
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
ι : Type u_1
f : ι → R[X]
m : Multiset ι
hm : m.Nodup
⊢ { val := m, nodup := hm }.prod f ≠ 0 →
    ({ val := m, nodup := hm }.prod f).roots = { val := m, nodup := hm }.val.bind fun i => (f i).roots
state_after: no goals
tactic: simpa [Multiset.prod_eq_zero_iff, Multiset.bind_map] using roots_multiset_prod (m.map f)
Theorem: Turing.PartrecToTM2.trList_ne_consₗ
File: Mathlib/Computability/TMToPartrec.lean

Proof steps:
state_before: a : ℕ
l : List ℕ
x : Γ'
h : x ∈ trList (a :: l)
⊢ x ≠ Γ'.consₗ
state_after: a : ℕ
l : List ℕ
x : Γ'
h : x ∈ trNat a ∨ x = Γ'.cons ∨ x ∈ trList l
⊢ x ≠ Γ'.consₗ
tactic: simp only [trList, List.mem_append, List.mem_cons] at h
state_before: a : ℕ
l : List ℕ
x : Γ'
h : x ∈ trNat a ∨ x = Γ'.cons ∨ x ∈ trList l
⊢ x ≠ Γ'.consₗ
state_after: case inl
a : ℕ
l : List ℕ
x : Γ'
h : x ∈ trNat a
⊢ x ≠ Γ'.consₗ

case inr.inl
a : ℕ
l : List ℕ
⊢ Γ'.cons ≠ Γ'.consₗ

case inr.inr
a : ℕ
l : List ℕ
x : Γ'
h : x ∈ trList l
⊢ x ≠ Γ'.consₗ
tactic: obtain h | rfl | h := h
Theorem: Matrix.transpose_fromRows
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

Proof steps:
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹¹ : Fintype m
inst✝¹⁰ : Fintype m₁
inst✝⁹ : Fintype m₂
inst✝⁸ : Fintype n
inst✝⁷ : Fintype n₁
inst✝⁶ : Fintype n₂
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq m₁
inst✝³ : DecidableEq m₂
inst✝² : DecidableEq n
inst✝¹ : DecidableEq n₁
inst✝ : DecidableEq n₂
A₁ : Matrix m₁ n R
A₂ : Matrix m₂ n R
⊢ (A₁.fromRows A₂)ᵀ = A₁ᵀ.fromColumns A₂ᵀ
state_after: no goals
tactic: ext i (j | j) <;> simp
Theorem: CategoryTheory.Limits.prod.map_id_comp
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
X✝ Y✝ X Y Z W : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝² : HasBinaryProduct W X
inst✝¹ : HasBinaryProduct W Y
inst✝ : HasBinaryProduct W Z
⊢ map (𝟙 W) (f ≫ g) = map (𝟙 W) f ≫ map (𝟙 W) g
state_after: no goals
tactic: simp
Theorem: Nat.count_eq_card_filter_range
File: Mathlib/Data/Nat/Count.lean

Proof steps:
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ count p n = (filter p (range n)).card
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ (List.filter (fun b => decide (p b)) (List.range n)).length = (filter p (range n)).card
tactic: rw [count, List.countP_eq_length_filter]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ (List.filter (fun b => decide (p b)) (List.range n)).length = (filter p (range n)).card
state_after: no goals
tactic: rfl
Theorem: MonoidHom.rangeRestrict_injective_iff
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N : Type u_5
P : Type u_6
inst✝¹ : Group N
inst✝ : Group P
K : Subgroup G
f : G →* N
⊢ Injective ⇑f.rangeRestrict ↔ Injective ⇑f
state_after: no goals
tactic: convert Set.injective_codRestrict _
Theorem: ProbabilityTheory.Kernel.measurableSet_mutuallySingular
File: Mathlib/Probability/Kernel/RadonNikodym.lean

Proof steps:
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
⊢ MeasurableSet {a | κ a ⟂ₘ η a}
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
⊢ MeasurableSet {a | (κ a) (κ.mutuallySingularSetSlice η a)ᶜ = 0}
tactic: simp_rw [← withDensity_rnDeriv_eq_zero_iff_mutuallySingular,
    withDensity_rnDeriv_eq_zero_iff_measure_eq_zero]
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
⊢ MeasurableSet {a | (κ a) (κ.mutuallySingularSetSlice η a)ᶜ = 0}
state_after: no goals
tactic: exact measurable_kernel_prod_mk_left (measurableSet_mutuallySingularSet κ η).compl
    (measurableSet_singleton 0)