ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AffineSubspace.isClosed_direction_iff
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

Proof steps:
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
s : AffineSubspace 𝕜 Q
⊢ IsClosed ↑s.direction ↔ IsClosed ↑s
state_after: case inl
α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
⊢ IsClosed ↑⊥.direction ↔ IsClosed ↑⊥

case inr.intro
α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
s : AffineSubspace 𝕜 Q
x : Q
hx : x ∈ ↑s
⊢ IsClosed ↑s.direction ↔ IsClosed ↑s
tactic: rcases s.eq_bot_or_nonempty with (rfl | ⟨x, hx⟩)
state_before: case inr.intro
α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
s : AffineSubspace 𝕜 Q
x : Q
hx : x ∈ ↑s
⊢ IsClosed ↑s.direction ↔ IsClosed ↑s
state_after: case inr.intro
α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
s : AffineSubspace 𝕜 Q
x : Q
hx : x ∈ ↑s
⊢ IsClosed ((fun x_1 => x_1 -ᵥ x) '' ↑s) ↔ IsClosed (⇑(IsometryEquiv.vaddConst x).toHomeomorph.symm '' ↑s)
tactic: rw [← (IsometryEquiv.vaddConst x).toHomeomorph.symm.isClosed_image,
    AffineSubspace.coe_direction_eq_vsub_set_right hx]
state_before: case inr.intro
α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
s : AffineSubspace 𝕜 Q
x : Q
hx : x ∈ ↑s
⊢ IsClosed ((fun x_1 => x_1 -ᵥ x) '' ↑s) ↔ IsClosed (⇑(IsometryEquiv.vaddConst x).toHomeomorph.symm '' ↑s)
state_after: no goals
tactic: rfl
Theorem: smul_inv_lt_iff_of_neg
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : LinearOrderedField α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
a : α
b₁ b₂ : β
inst✝ : PosSMulStrictMono α β
h : a < 0
⊢ b₁ < a⁻¹ • b₂ ↔ b₂ < a • b₁
state_after: no goals
tactic: rw [← smul_lt_smul_iff_of_neg_left h, smul_inv_smul₀ h.ne]
Theorem: PSet.mem_sUnion
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: α : Type u
A : α → PSet
y : PSet
x✝ : y ∈ ⋃₀ mk α A
a : (mk α A).Type
c : ((mk α A).Func a).Type
e : y.Equiv ((A a).Func c)
this : (A a).Func c ∈ mk (A a).Type (A a).Func
⊢ (A a).Func c ∈ A (?m.17187 α A y x✝ a c e this)
state_after: no goals
tactic: rwa [eta] at this
state_before: α : Type u
A : α → PSet
y : PSet
x✝ : ∃ z ∈ mk α A, y ∈ z
β : Type u
B : β → PSet
a : (mk α A).Type
e : (mk β B).Equiv (A a)
b : (mk β B).Type
yb : y.Equiv ((mk β B).Func b)
⊢ y ∈ ⋃₀ mk α A
state_after: α : Type u
A : α → PSet
y : PSet
x✝ : ∃ z ∈ mk α A, y ∈ z
β : Type u
B : β → PSet
a : (mk α A).Type
e : (mk β B).Equiv (mk (A a).Type (A a).Func)
b : (mk β B).Type
yb : y.Equiv ((mk β B).Func b)
⊢ y ∈ ⋃₀ mk α A
tactic: rw [← eta (A a)] at e
state_before: α : Type u
A : α → PSet
y : PSet
x✝ : ∃ z ∈ mk α A, y ∈ z
β : Type u
B : β → PSet
a : (mk α A).Type
e : (mk β B).Equiv (mk (A a).Type (A a).Func)
b : (mk β B).Type
yb : y.Equiv ((mk β B).Func b)
⊢ y ∈ ⋃₀ mk α A
state_after: no goals
tactic: exact
        let ⟨βt, _⟩ := e
        let ⟨c, bc⟩ := βt b
        ⟨⟨a, c⟩, yb.trans bc⟩
Theorem: Finset.sum_Icc_succ_top
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M
a b : ℕ
hab : a ≤ b + 1
f : ℕ → M
⊢ ∏ k ∈ Icc a (b + 1), f k = (∏ k ∈ Icc a b, f k) * f (b + 1)
state_after: no goals
tactic: rw [← Nat.Ico_succ_right, prod_Ico_succ_top hab, Nat.Ico_succ_right]
Theorem: MeasureTheory.hitting_le_of_mem
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 : ι
hin : n ≤ i
him : i ≤ m
his : u i ω ∈ s
⊢ hitting u s n m ω ≤ i
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
hin : n ≤ i
him : i ≤ m
his : u i ω ∈ s
h_exists : ∃ k ∈ Set.Icc n m, u k ω ∈ s
⊢ hitting u s n m ω ≤ i
tactic: have h_exists : ∃ k ∈ Set.Icc n m, u k ω ∈ s := ⟨i, ⟨hin, him⟩, his⟩
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
hin : n ≤ i
him : i ≤ m
his : u i ω ∈ s
h_exists : ∃ k ∈ Set.Icc n m, u k ω ∈ s
⊢ hitting u s n m ω ≤ i
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
hin : n ≤ i
him : i ≤ m
his : u i ω ∈ s
h_exists : ∃ k ∈ Set.Icc n m, u k ω ∈ s
⊢ sInf (Set.Icc n m ∩ {i | u i ω ∈ s}) ≤ i
tactic: simp_rw [hitting, if_pos h_exists]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
hin : n ≤ i
him : i ≤ m
his : u i ω ∈ s
h_exists : ∃ k ∈ Set.Icc n m, u k ω ∈ s
⊢ sInf (Set.Icc n m ∩ {i | u i ω ∈ s}) ≤ i
state_after: no goals
tactic: exact csInf_le (BddBelow.inter_of_left bddBelow_Icc) (Set.mem_inter ⟨hin, him⟩ his)
Theorem: CategoryTheory.GrothendieckTopology.toImageSheaf_ι
File: Mathlib/CategoryTheory/Sites/Subsheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F✝ F'✝ F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F✝
F F' : Sheaf J (Type w)
f : F ⟶ F'
⊢ toImageSheaf f ≫ imageSheafι f = f
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F✝ F'✝ F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F✝
F F' : Sheaf J (Type w)
f : F ⟶ F'
⊢ (toImageSheaf f ≫ imageSheafι f).val = f.val
tactic: ext1
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F✝ F'✝ F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F✝
F F' : Sheaf J (Type w)
f : F ⟶ F'
⊢ (toImageSheaf f ≫ imageSheafι f).val = f.val
state_after: no goals
tactic: simp [toImagePresheafSheafify]
Theorem: MvPowerSeries.eq_mul_inv_iff_mul_eq
File: Mathlib/RingTheory/MvPowerSeries/Inverse.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
k✝ : Type u_3
inst✝ : Field k✝
φ₁ φ₂ φ₃ : MvPowerSeries σ k✝
h : (constantCoeff σ k✝) φ₃ ≠ 0
k : φ₁ = φ₂ * φ₃⁻¹
⊢ φ₁ * φ₃ = φ₂
state_after: no goals
tactic: simp [k, mul_assoc, MvPowerSeries.inv_mul_cancel _ h]
state_before: σ : Type u_1
R : Type u_2
k✝ : Type u_3
inst✝ : Field k✝
φ₁ φ₂ φ₃ : MvPowerSeries σ k✝
h : (constantCoeff σ k✝) φ₃ ≠ 0
k : φ₁ * φ₃ = φ₂
⊢ φ₁ = φ₂ * φ₃⁻¹
state_after: no goals
tactic: simp [← k, mul_assoc, MvPowerSeries.mul_inv_cancel _ h]
Theorem: List.append_right_eq_self
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ x y : List α
⊢ x ++ y = x ↔ y = []
state_after: no goals
tactic: rw [← append_right_inj (t₁ := y), append_nil]
Theorem: padicNorm.padicNorm_of_prime_of_ne
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

Proof steps:
state_before: p q : ℕ
p_prime : Fact (Nat.Prime p)
q_prime : Fact (Nat.Prime q)
neq : p ≠ q
⊢ padicNorm p ↑q = 1
state_after: p✝ q : ℕ
p_prime : Fact (Nat.Prime p✝)
q_prime : Fact (Nat.Prime q)
neq : p✝ ≠ q
p : padicValRat p✝ ↑q = 0
⊢ padicNorm p✝ ↑q = 1
tactic: have p : padicValRat p q = 0 := mod_cast padicValNat_primes neq
state_before: p✝ q : ℕ
p_prime : Fact (Nat.Prime p✝)
q_prime : Fact (Nat.Prime q)
neq : p✝ ≠ q
p : padicValRat p✝ ↑q = 0
⊢ padicNorm p✝ ↑q = 1
state_after: p✝ q : ℕ
p_prime : Fact (Nat.Prime p✝)
q_prime : Fact (Nat.Prime q)
neq : p✝ ≠ q
p : padicValRat p✝ ↑q = 0
⊢ (if ↑q = 0 then 0 else ↑p✝ ^ (-0)) = 1
tactic: rw [padicNorm, p]
state_before: p✝ q : ℕ
p_prime : Fact (Nat.Prime p✝)
q_prime : Fact (Nat.Prime q)
neq : p✝ ≠ q
p : padicValRat p✝ ↑q = 0
⊢ (if ↑q = 0 then 0 else ↑p✝ ^ (-0)) = 1
state_after: no goals
tactic: simp [q_prime.1.ne_zero]
Theorem: MeasureTheory.lintegral_lintegral_mul
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν✝ : Measure α
β : Type u_5
inst✝ : MeasurableSpace β
ν : Measure β
f : α → ℝ≥0∞
g : β → ℝ≥0∞
hf : AEMeasurable f μ
hg : AEMeasurable g ν
⊢ ∫⁻ (x : α), ∫⁻ (y : β), f x * g y ∂ν ∂μ = (∫⁻ (x : α), f x ∂μ) * ∫⁻ (y : β), g y ∂ν
state_after: no goals
tactic: simp [lintegral_const_mul'' _ hg, lintegral_mul_const'' _ hf]
Theorem: Matrix.vecMul_stdBasis
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
⊢ ((LinearMap.stdBasis R (fun x => R) i) 1 ᵥ* M) j = M i j
state_after: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
⊢ ((LinearMap.stdBasis R (fun x => R) i) 1 ᵥ* M) j = M i j
tactic: have : (∑ i', (if i = i' then 1 else 0) * M i' j) = M i j := by
    simp_rw [boole_mul, Finset.sum_ite_eq, Finset.mem_univ, if_true]
state_before: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
⊢ ((LinearMap.stdBasis R (fun x => R) i) 1 ᵥ* M) j = M i j
state_after: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
⊢ ∑ x : m, (LinearMap.stdBasis R (fun x => R) i) 1 x * M x j = M i j
tactic: simp only [vecMul, dotProduct]
state_before: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
⊢ ∑ x : m, (LinearMap.stdBasis R (fun x => R) i) 1 x * M x j = M i j
state_after: case h.e'_2.a.h.e'_5
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
x✝ : m
a✝ : x✝ ∈ Finset.univ
⊢ (LinearMap.stdBasis R (fun x => R) i) 1 x✝ = if i = x✝ then 1 else 0
tactic: convert this
state_before: case h.e'_2.a.h.e'_5
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
x✝ : m
a✝ : x✝ ∈ Finset.univ
⊢ (LinearMap.stdBasis R (fun x => R) i) 1 x✝ = if i = x✝ then 1 else 0
state_after: case pos
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
x✝ : m
a✝ : x✝ ∈ Finset.univ
h : i = x✝
⊢ Function.update 0 i 1 x✝ = 1

case neg
R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
i : m
j : n
this : ∑ i' : m, (if i = i' then 1 else 0) * M i' j = M i j
x✝ : m
a✝ : x✝ ∈ Finset.univ
h : ¬i = x✝
⊢ Function.update 0 i 1 x✝ = 0
tactic: split_ifs with h <;> simp only [stdBasis_apply]
Theorem: Finset.sum_of_isEmpty
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : IsEmpty α
s : Finset α
⊢ ∏ i ∈ s, f i = 1
state_after: no goals
tactic: rw [eq_empty_of_isEmpty s, prod_empty]
Theorem: TensorProduct.exists_finset
File: Mathlib/LinearAlgebra/TensorProduct/Finiteness.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
M₁ M₂ : Submodule R M
N₁ N₂ : Submodule R N
x : M ⊗[R] N
⊢ ∃ S, x = ∑ i ∈ S, i.1 ⊗ₜ[R] i.2
state_after: case intro
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
M₁ M₂ : Submodule R M
N₁ N₂ : Submodule R N
x : M ⊗[R] N
S : M →₀ N
h : x = S.sum fun m n => m ⊗ₜ[R] n
⊢ ∃ S, x = ∑ i ∈ S, i.1 ⊗ₜ[R] i.2
tactic: obtain ⟨S, h⟩ := exists_finsupp_left x
state_before: case intro
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
M₁ M₂ : Submodule R M
N₁ N₂ : Submodule R N
x : M ⊗[R] N
S : M →₀ N
h : x = S.sum fun m n => m ⊗ₜ[R] n
⊢ ∃ S, x = ∑ i ∈ S, i.1 ⊗ₜ[R] i.2
state_after: case h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
M₁ M₂ : Submodule R M
N₁ N₂ : Submodule R N
x : M ⊗[R] N
S : M →₀ N
h : x = S.sum fun m n => m ⊗ₜ[R] n
⊢ x = ∑ i ∈ S.graph, i.1 ⊗ₜ[R] i.2
tactic: use S.graph
state_before: case h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
M₁ M₂ : Submodule R M
N₁ N₂ : Submodule R N
x : M ⊗[R] N
S : M →₀ N
h : x = S.sum fun m n => m ⊗ₜ[R] n
⊢ x = ∑ i ∈ S.graph, i.1 ⊗ₜ[R] i.2
state_after: case h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
M₁ M₂ : Submodule R M
N₁ N₂ : Submodule R N
x : M ⊗[R] N
S : M →₀ N
h : x = S.sum fun m n => m ⊗ₜ[R] n
⊢ ∑ a ∈ S.support, a ⊗ₜ[R] S a = ∑ i ∈ S.graph, i.1 ⊗ₜ[R] i.2
tactic: rw [h, Finsupp.sum]
state_before: case h
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
M₁ M₂ : Submodule R M
N₁ N₂ : Submodule R N
x : M ⊗[R] N
S : M →₀ N
h : x = S.sum fun m n => m ⊗ₜ[R] n
⊢ ∑ a ∈ S.support, a ⊗ₜ[R] S a = ∑ i ∈ S.graph, i.1 ⊗ₜ[R] i.2
state_after: no goals
tactic: apply Finset.sum_nbij' (fun m ↦ ⟨m, S m⟩) Prod.fst <;> simp
Theorem: CategoryTheory.Limits.Cone.ofTrident_π
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
F : WalkingParallelFamily J ⥤ C
t : Trident fun j => F.map (line j)
j : WalkingParallelFamily J
⊢ (parallelFamily fun j => F.map (line j)).obj j = F.obj j
state_after: no goals
tactic: cases j <;> aesop_cat
Theorem: Matrix.eq_zero_of_forall_index_sum_mul_pow_eq_zero
File: Mathlib/LinearAlgebra/Vandermonde.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝² : CommRing R✝
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ v = 0
state_after: R✝ : Type u_1
inst✝² : CommRing R✝
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ ∀ (j : Fin n), ∑ i : Fin n, f j ^ ↑i * v i = 0
tactic: apply eq_zero_of_forall_index_sum_pow_mul_eq_zero hf
state_before: R✝ : Type u_1
inst✝² : CommRing R✝
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ ∀ (j : Fin n), ∑ i : Fin n, f j ^ ↑i * v i = 0
state_after: R✝ : Type u_1
inst✝² : CommRing R✝
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ ∀ (j : Fin n), ∑ x : Fin n, v x * f j ^ ↑x = 0
tactic: simp_rw [mul_comm]
state_before: R✝ : Type u_1
inst✝² : CommRing R✝
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
f v : Fin n → R
hf : Function.Injective f
hfv : ∀ (j : Fin n), ∑ i : Fin n, v i * f j ^ ↑i = 0
⊢ ∀ (j : Fin n), ∑ x : Fin n, v x * f j ^ ↑x = 0
state_after: no goals
tactic: exact hfv
Theorem: CategoryTheory.monotone_isoClosure
File: Mathlib/CategoryTheory/ClosedUnderIsomorphisms.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q : C → Prop
h : P ≤ Q
⊢ isoClosure P ≤ isoClosure Q
state_after: case intro.intro.intro
C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q : C → Prop
h : P ≤ Q
X X' : C
hX' : P X'
e : X ≅ X'
⊢ isoClosure Q X
tactic: rintro X ⟨X', hX', ⟨e⟩⟩
state_before: case intro.intro.intro
C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q : C → Prop
h : P ≤ Q
X X' : C
hX' : P X'
e : X ≅ X'
⊢ isoClosure Q X
state_after: no goals
tactic: exact ⟨X', h _ hX', ⟨e⟩⟩
Theorem: tprod_subtype
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
s : Set β
f : β → α
⊢ ∏' (x : ↑s), f ↑x = ∏' (x : β), s.mulIndicator f x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
s : Set β
f : β → α
⊢ ∀ (b : ↑s), f ↑b = s.mulIndicator f ↑b
tactic: rw [← tprod_subtype_eq_of_mulSupport_subset Set.mulSupport_mulIndicator_subset, tprod_congr]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
s : Set β
f : β → α
⊢ ∀ (b : ↑s), f ↑b = s.mulIndicator f ↑b
state_after: no goals
tactic: simp
Theorem: Commute.geom_sum₂_mul
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n : ℕ
⊢ (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ n
state_after: α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n : ℕ
this : (∑ i ∈ range n, (x - y + y) ^ i * y ^ (n - 1 - i)) * (x - y) + y ^ n = (x - y + y) ^ n
⊢ (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ n
tactic: have := (h.sub_left (Commute.refl y)).geom_sum₂_mul_add n
state_before: α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n : ℕ
this : (∑ i ∈ range n, (x - y + y) ^ i * y ^ (n - 1 - i)) * (x - y) + y ^ n = (x - y + y) ^ n
⊢ (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ n
state_after: α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n : ℕ
this : (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) + y ^ n = x ^ n
⊢ (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ n
tactic: rw [sub_add_cancel] at this
state_before: α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n : ℕ
this : (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) + y ^ n = x ^ n
⊢ (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ n
state_after: no goals
tactic: rw [← this, add_sub_cancel_right]
Theorem: Function.Surjective.iSup_congr
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : SupSet α
f g✝ : ι → α
g : ι' → α
h : ι → ι'
h1 : Surjective h
h2 : ∀ (x : ι), g (h x) = f x
⊢ ⨆ x, f x = ⨆ y, g y
state_after: case h.e'_2.h.e'_4.h
α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : SupSet α
f g✝ : ι → α
g : ι' → α
h : ι → ι'
h1 : Surjective h
h2 : ∀ (x : ι), g (h x) = f x
x✝ : ι
⊢ f x✝ = g (h x✝)
tactic: convert h1.iSup_comp g
state_before: case h.e'_2.h.e'_4.h
α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : SupSet α
f g✝ : ι → α
g : ι' → α
h : ι → ι'
h1 : Surjective h
h2 : ∀ (x : ι), g (h x) = f x
x✝ : ι
⊢ f x✝ = g (h x✝)
state_after: no goals
tactic: exact (h2 _).symm
Theorem: Filter.frequently_false
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
⊢ ¬∃ᶠ (x : α) in f, False
state_after: no goals
tactic: simp
Theorem: fderiv_neg
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
⊢ fderiv 𝕜 (fun y => -f y) x = -fderiv 𝕜 f x
state_after: no goals
tactic: simp only [← fderivWithin_univ, fderivWithin_neg uniqueDiffWithinAt_univ]
Theorem: Topology.IsScottHausdorff.isOpen_iff
File: Mathlib/Topology/Order/ScottTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
s✝ : Set α
inst✝¹ : TopologicalSpace α
inst✝ : IsScottHausdorff α
s : Set α
⊢ IsOpen s ↔
    ∀ ⦃d : Set α⦄,
      d.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) d → ∀ ⦃a : α⦄, IsLUB d a → a ∈ s → ∃ b ∈ d, Ici b ∩ d ⊆ s
state_after: no goals
tactic: rfl
Theorem: Matrix.TransvectionStruct.sumInl_toMatrix_prod_mul
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
M : Matrix n n R
L : List (TransvectionStruct n R)
N : Matrix p p R
⊢ (List.map (toMatrix ∘ sumInl p) L).prod * fromBlocks M 0 0 N = fromBlocks ((List.map toMatrix L).prod * M) 0 0 N
state_after: case nil
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
M : Matrix n n R
N : Matrix p p R
⊢ (List.map (toMatrix ∘ sumInl p) []).prod * fromBlocks M 0 0 N = fromBlocks ((List.map toMatrix []).prod * M) 0 0 N

case cons
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁵ : Field 𝕜
inst✝⁴ : DecidableEq n
inst✝³ : DecidableEq p
inst✝² : CommRing R
i j : n
inst✝¹ : Fintype n
inst✝ : Fintype p
M : Matrix n n R
N : Matrix p p R
t : TransvectionStruct n R
L : List (TransvectionStruct n R)
IH : (List.map (toMatrix ∘ sumInl p) L).prod * fromBlocks M 0 0 N = fromBlocks ((List.map toMatrix L).prod * M) 0 0 N
⊢ (List.map (toMatrix ∘ sumInl p) (t :: L)).prod * fromBlocks M 0 0 N =
    fromBlocks ((List.map toMatrix (t :: L)).prod * M) 0 0 N
tactic: induction' L with t L IH