ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: groupCohomology.dTwo_comp_dOne
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
⊢ dTwo A ∘ₗ dOne A = 0
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
⊢ ModuleCat.ofHom (dOne A) ≫ ModuleCat.ofHom (dTwo A) = 0
tactic: show ModuleCat.ofHom (dOne A) ≫ ModuleCat.ofHom (dTwo A) = _
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
⊢ ModuleCat.ofHom (dOne A) ≫ ModuleCat.ofHom (dTwo A) = 0
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
h1 : ↑(oneCochainsLequiv A) ≫ ModuleCat.ofHom (dOne A) = (inhomogeneousCochains A).d 1 2 ≫ ↑(twoCochainsLequiv A)
⊢ ModuleCat.ofHom (dOne A) ≫ ModuleCat.ofHom (dTwo A) = 0
tactic: have h1 : _ ≫ ModuleCat.ofHom (dOne A) = _ ≫ _ := congr_arg ModuleCat.ofHom (dOne_comp_eq A)
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
h1 : ↑(oneCochainsLequiv A) ≫ ModuleCat.ofHom (dOne A) = (inhomogeneousCochains A).d 1 2 ≫ ↑(twoCochainsLequiv A)
⊢ ModuleCat.ofHom (dOne A) ≫ ModuleCat.ofHom (dTwo A) = 0
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
h1 : ↑(oneCochainsLequiv A) ≫ ModuleCat.ofHom (dOne A) = (inhomogeneousCochains A).d 1 2 ≫ ↑(twoCochainsLequiv A)
h2 : ↑(twoCochainsLequiv A) ≫ ModuleCat.ofHom (dTwo A) = (inhomogeneousCochains A).d 2 3 ≫ ↑(threeCochainsLequiv A)
⊢ ModuleCat.ofHom (dOne A) ≫ ModuleCat.ofHom (dTwo A) = 0
tactic: have h2 : _ ≫ ModuleCat.ofHom (dTwo A) = _ ≫ _ := congr_arg ModuleCat.ofHom (dTwo_comp_eq A)
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
h1 : ↑(oneCochainsLequiv A) ≫ ModuleCat.ofHom (dOne A) = (inhomogeneousCochains A).d 1 2 ≫ ↑(twoCochainsLequiv A)
h2 : ↑(twoCochainsLequiv A) ≫ ModuleCat.ofHom (dTwo A) = (inhomogeneousCochains A).d 2 3 ≫ ↑(threeCochainsLequiv A)
⊢ ModuleCat.ofHom (dOne A) ≫ ModuleCat.ofHom (dTwo A) = 0
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
h1 :
  (oneCochainsLequiv A).toModuleIso.hom ≫ ModuleCat.ofHom (dOne A) =
    (inhomogeneousCochains A).d 1 2 ≫ (twoCochainsLequiv A).toModuleIso.hom
h2 :
  (twoCochainsLequiv A).toModuleIso.hom ≫ ModuleCat.ofHom (dTwo A) =
    (inhomogeneousCochains A).d 2 3 ≫ (threeCochainsLequiv A).toModuleIso.hom
⊢ ModuleCat.ofHom (dOne A) ≫ ModuleCat.ofHom (dTwo A) = 0
tactic: simp only [← LinearEquiv.toModuleIso_hom] at h1 h2
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
h1 :
  (oneCochainsLequiv A).toModuleIso.hom ≫ ModuleCat.ofHom (dOne A) =
    (inhomogeneousCochains A).d 1 2 ≫ (twoCochainsLequiv A).toModuleIso.hom
h2 :
  (twoCochainsLequiv A).toModuleIso.hom ≫ ModuleCat.ofHom (dTwo A) =
    (inhomogeneousCochains A).d 2 3 ≫ (threeCochainsLequiv A).toModuleIso.hom
⊢ ModuleCat.ofHom (dOne A) ≫ ModuleCat.ofHom (dTwo A) = 0
state_after: no goals
tactic: simp only [(Iso.eq_inv_comp _).2 h2, (Iso.eq_inv_comp _).2 h1,
    Category.assoc, Iso.hom_inv_id_assoc, HomologicalComplex.d_comp_d_assoc, zero_comp, comp_zero]
Theorem: Mathlib.Vector.toList_cons
File: Mathlib/Data/Vector/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
φ : Type w
n : ℕ
a : α
v : Vector α n
⊢ (cons a v).toList = a :: v.toList
state_after: case mk
α : Type u
β : Type v
φ : Type w
n : ℕ
a : α
val✝ : List α
property✝ : val✝.length = n
⊢ (cons a ⟨val✝, property✝⟩).toList = a :: toList ⟨val✝, property✝⟩
tactic: cases v
state_before: case mk
α : Type u
β : Type v
φ : Type w
n : ℕ
a : α
val✝ : List α
property✝ : val✝.length = n
⊢ (cons a ⟨val✝, property✝⟩).toList = a :: toList ⟨val✝, property✝⟩
state_after: no goals
tactic: rfl
Theorem: Filter.hasBasis_pure
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' : ι'
x : α
⊢ (pure x).HasBasis (fun x => True) fun x_1 => {x}
state_after: no goals
tactic: simp only [← principal_singleton, hasBasis_principal]
Theorem: TopologicalSpace.isTopologicalBasis_opens
File: Mathlib/Topology/Bases.lean

Proof steps:
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s : Set α
⊢ ∀ u ∈ {U | IsOpen U}, IsOpen u
state_after: no goals
tactic: tauto
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s : Set α
⊢ ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v ∈ {U | IsOpen U}, a ∈ v ∧ v ⊆ u
state_after: no goals
tactic: tauto
Theorem: CategoryTheory.injective_of_preservesFiniteColimits_preadditiveYonedaObj
File: Mathlib/CategoryTheory/Abelian/Injective.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
J : C
hP : PreservesFiniteColimits (preadditiveYonedaObj J)
⊢ Injective J
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
J : C
hP : PreservesFiniteColimits (preadditiveYonedaObj J)
⊢ (preadditiveYonedaObj J).PreservesEpimorphisms
tactic: rw [injective_iff_preservesEpimorphisms_preadditive_yoneda_obj']
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
J : C
hP : PreservesFiniteColimits (preadditiveYonedaObj J)
⊢ (preadditiveYonedaObj J).PreservesEpimorphisms
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
J : C
hP : PreservesFiniteColimits (preadditiveYonedaObj J)
this : (preadditiveYonedaObj J).PreservesHomology
⊢ (preadditiveYonedaObj J).PreservesEpimorphisms
tactic: have := Functor.preservesHomologyOfExact (preadditiveYonedaObj J)
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
J : C
hP : PreservesFiniteColimits (preadditiveYonedaObj J)
this : (preadditiveYonedaObj J).PreservesHomology
⊢ (preadditiveYonedaObj J).PreservesEpimorphisms
state_after: no goals
tactic: infer_instance
Theorem: MeasureTheory.eLpNorm_zero
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
⊢ eLpNorm 0 p μ = 0
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
h0 : p = 0
⊢ eLpNorm 0 p μ = 0

case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
h0 : ¬p = 0
⊢ eLpNorm 0 p μ = 0
tactic: by_cases h0 : p = 0
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
h0 : ¬p = 0
⊢ eLpNorm 0 p μ = 0
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
h0 : ¬p = 0
h_top : p = ⊤
⊢ eLpNorm 0 p μ = 0

case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
h0 : ¬p = 0
h_top : ¬p = ⊤
⊢ eLpNorm 0 p μ = 0
tactic: by_cases h_top : p = ∞
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
h0 : ¬p = 0
h_top : ¬p = ⊤
⊢ eLpNorm 0 p μ = 0
state_after: case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
h0 : p ≠ 0
h_top : ¬p = ⊤
⊢ eLpNorm 0 p μ = 0
tactic: rw [← Ne] at h0
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
h0 : p ≠ 0
h_top : ¬p = ⊤
⊢ eLpNorm 0 p μ = 0
state_after: no goals
tactic: simp [eLpNorm_eq_eLpNorm' h0 h_top, ENNReal.toReal_pos h0 h_top]
Theorem: RelEmbedding.not_acc_of_decreasing_seq
File: Mathlib/Order/OrderIsoNat.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
f : (fun x x_1 => x > x_1) ↪r r
k : ℕ
⊢ ¬Acc r (f k)
state_after: α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
f : (fun x x_1 => x > x_1) ↪r r
k : ℕ
⊢ Nonempty { f_1 // f k ∈ Set.range ⇑f_1 }
tactic: rw [acc_iff_no_decreasing_seq, not_isEmpty_iff]
state_before: α : Type u_1
r : α → α → Prop
inst✝ : IsStrictOrder α r
f : (fun x x_1 => x > x_1) ↪r r
k : ℕ
⊢ Nonempty { f_1 // f k ∈ Set.range ⇑f_1 }
state_after: no goals
tactic: exact ⟨⟨f, k, rfl⟩⟩
Theorem: Polynomial.natDegree_ne_zero_induction_on
File: Mathlib/Algebra/Polynomial/Inductions.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
M : R[X] → Prop
f : R[X]
f0 : f.natDegree ≠ 0
h_C_add : ∀ {a : R} {p : R[X]}, M p → M (C a + p)
h_add : ∀ {p q : R[X]}, M p → M q → M (p + q)
h_monomial : ∀ {n : ℕ} {a : R}, a ≠ 0 → n ≠ 0 → M ((monomial n) a)
⊢ M f
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
M : R[X] → Prop
f : R[X]
f0 : f.natDegree ≠ 0
h_C_add : ∀ {a : R} {p : R[X]}, M p → M (C a + p)
h_add : ∀ {p q : R[X]}, M p → M q → M (p + q)
h_monomial : ∀ {n : ℕ} {a : R}, a ≠ 0 → n ≠ 0 → M ((monomial n) a)
⊢ f.natDegree = 0 ∨ M f
tactic: suffices f.natDegree = 0 ∨ M f from Or.recOn this (fun h => (f0 h).elim) id
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
M : R[X] → Prop
f : R[X]
f0 : f.natDegree ≠ 0
h_C_add : ∀ {a : R} {p : R[X]}, M p → M (C a + p)
h_add : ∀ {p q : R[X]}, M p → M q → M (p + q)
h_monomial : ∀ {n : ℕ} {a : R}, a ≠ 0 → n ≠ 0 → M ((monomial n) a)
⊢ f.natDegree = 0 ∨ M f
state_after: case refine_1
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
M : R[X] → Prop
f : R[X]
f0 : f.natDegree ≠ 0
h_C_add : ∀ {a : R} {p : R[X]}, M p → M (C a + p)
h_add : ∀ {p q : R[X]}, M p → M q → M (p + q)
h_monomial : ∀ {n : ℕ} {a : R}, a ≠ 0 → n ≠ 0 → M ((monomial n) a)
⊢ ∀ (a : R), (C a).natDegree = 0 ∨ M (C a)

case refine_2
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
M : R[X] → Prop
f : R[X]
f0 : f.natDegree ≠ 0
h_C_add : ∀ {a : R} {p : R[X]}, M p → M (C a + p)
h_add : ∀ {p q : R[X]}, M p → M q → M (p + q)
h_monomial : ∀ {n : ℕ} {a : R}, a ≠ 0 → n ≠ 0 → M ((monomial n) a)
⊢ ∀ (p q : R[X]), p.natDegree = 0 ∨ M p → q.natDegree = 0 ∨ M q → (p + q).natDegree = 0 ∨ M (p + q)

case refine_3
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
M : R[X] → Prop
f : R[X]
f0 : f.natDegree ≠ 0
h_C_add : ∀ {a : R} {p : R[X]}, M p → M (C a + p)
h_add : ∀ {p q : R[X]}, M p → M q → M (p + q)
h_monomial : ∀ {n : ℕ} {a : R}, a ≠ 0 → n ≠ 0 → M ((monomial n) a)
⊢ ∀ (n : ℕ) (a : R),
    (C a * X ^ n).natDegree = 0 ∨ M (C a * X ^ n) → (C a * X ^ (n + 1)).natDegree = 0 ∨ M (C a * X ^ (n + 1))
tactic: refine Polynomial.induction_on f ?_ ?_ ?_
Theorem: Set.Ico_diff_Iio
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ico a b \ Iio c = Ico (max a c) b
state_after: no goals
tactic: rw [diff_eq, compl_Iio, Ico_inter_Ici, sup_eq_max]
Theorem: MvPolynomial.eval₂_mul
File: Mathlib/Algebra/MvPolynomial/Basic.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 : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ {p : MvPolynomial σ R}, eval₂ f g (p * q) = eval₂ f g p * eval₂ f g q
state_after: case h_C
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ (a : R) {p : MvPolynomial σ R}, eval₂ f g (p * C a) = eval₂ f g p * eval₂ f g (C a)

case h_add
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ (p q : MvPolynomial σ R),
    (∀ {p_1 : MvPolynomial σ R}, eval₂ f g (p_1 * p) = eval₂ f g p_1 * eval₂ f g p) →
      (∀ {p : MvPolynomial σ R}, eval₂ f g (p * q) = eval₂ f g p * eval₂ f g q) →
        ∀ {p_1 : MvPolynomial σ R}, eval₂ f g (p_1 * (p + q)) = eval₂ f g p_1 * eval₂ f g (p + q)

case h_X
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ (p : MvPolynomial σ R) (n : σ),
    (∀ {p_1 : MvPolynomial σ R}, eval₂ f g (p_1 * p) = eval₂ f g p_1 * eval₂ f g p) →
      ∀ {p_1 : MvPolynomial σ R}, eval₂ f g (p_1 * (p * X n)) = eval₂ f g p_1 * eval₂ f g (p * X n)
tactic: apply MvPolynomial.induction_on q
Theorem: Int.ediv_dvd_ediv
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a✝ b✝ c✝ d m n a b c : ℤ
az : a = 0
⊢ a * b / a ∣ a * b * c / a
state_after: no goals
tactic: simp [az]
state_before: a✝ b✝ c✝ d m n a b c : ℤ
az : ¬a = 0
⊢ a * b / a ∣ a * b * c / a
state_after: a✝ b✝ c✝ d m n a b c : ℤ
az : ¬a = 0
⊢ b ∣ b * c
tactic: rw [Int.mul_ediv_cancel_left _ az, Int.mul_assoc, Int.mul_ediv_cancel_left _ az]
state_before: a✝ b✝ c✝ d m n a b c : ℤ
az : ¬a = 0
⊢ b ∣ b * c
state_after: no goals
tactic: apply Int.dvd_mul_right
Theorem: Equiv.Perm.support_prod_le
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
⊢ l.prod.support ≤ List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map support l)
state_after: case nil
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
⊢ [].prod.support ≤ List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map support [])

case cons
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g hd : Perm α
tl : List (Perm α)
hl : tl.prod.support ≤ List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map support tl)
⊢ (hd :: tl).prod.support ≤ List.foldr (fun x x_1 => x ⊔ x_1) ⊥ (List.map support (hd :: tl))
tactic: induction' l with hd tl hl
Theorem: Matrix.toLinearMap₂'_apply
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M✝ : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : AddCommMonoid N₂
inst✝¹⁴ : Module R N₂
inst✝¹³ : Semiring R₁
inst✝¹² : Semiring R₂
inst✝¹¹ : SMulCommClass R R N₂
inst✝¹⁰ : Semiring S₁
inst✝⁹ : Semiring S₂
inst✝⁸ : Module S₁ N₂
inst✝⁷ : Module S₂ N₂
inst✝⁶ : SMulCommClass S₁ R N₂
inst✝⁵ : SMulCommClass S₂ R N₂
inst✝⁴ : SMulCommClass S₂ S₁ N₂
σ₁ : R₁ →+* S₁
σ₂ : R₂ →+* S₂
inst✝³ : Fintype n
inst✝² : Fintype m
inst✝¹ : DecidableEq n
inst✝ : DecidableEq m
M : Matrix n m N₂
x : n → S₁
y : m → S₂
x✝³ : n
x✝² : x✝³ ∈ univ
x✝¹ : m
x✝ : x✝¹ ∈ univ
⊢ (RingHom.id S₂) (y x✝¹) •> (RingHom.id S₁) (x x✝³) •> M x✝³ x✝¹ = x x✝³ •> y x✝¹ •> M x✝³ x✝¹
state_after: no goals
tactic: rw [RingHom.id_apply, RingHom.id_apply, smul_comm]
Theorem: collinear_iff_not_affineIndependent
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : Fin 3 → P
⊢ Collinear k (Set.range p) ↔ ¬AffineIndependent k p
state_after: no goals
tactic: rw [collinear_iff_finrank_le_one,
    finrank_vectorSpan_le_iff_not_affineIndependent k p (Fintype.card_fin 3)]
Theorem: NormedAddGroupHom.antilipschitz_of_norm_ge
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
K : ℝ≥0
h : ∀ (x : V₁), ‖x‖ ≤ ↑K * ‖f x‖
x y : V₁
⊢ dist x y ≤ ↑K * dist (f x) (f y)
state_after: no goals
tactic: simpa only [dist_eq_norm, map_sub] using h (x - y)
Theorem: PowerSeries.trunc_trunc_mul
File: Mathlib/RingTheory/PowerSeries/Trunc.lean

Proof steps:
state_before: R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f g : R⟦X⟧
⊢ trunc n (↑(trunc n f) * g) = trunc n (f * g)
state_after: case a
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f g : R⟦X⟧
m : ℕ
⊢ (trunc n (↑(trunc n f) * g)).coeff m = (trunc n (f * g)).coeff m
tactic: ext m
state_before: case a
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f g : R⟦X⟧
m : ℕ
⊢ (trunc n (↑(trunc n f) * g)).coeff m = (trunc n (f * g)).coeff m
state_after: case a
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f g : R⟦X⟧
m : ℕ
⊢ (if m < n then (coeff R m) (↑(trunc n f) * g) else 0) = if m < n then (coeff R m) (f * g) else 0
tactic: rw [coeff_trunc, coeff_trunc]
state_before: case a
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f g : R⟦X⟧
m : ℕ
⊢ (if m < n then (coeff R m) (↑(trunc n f) * g) else 0) = if m < n then (coeff R m) (f * g) else 0
state_after: case pos
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f g : R⟦X⟧
m : ℕ
h : m < n
⊢ (coeff R m) (↑(trunc n f) * g) = (coeff R m) (f * g)

case neg
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f g : R⟦X⟧
m : ℕ
h : ¬m < n
⊢ 0 = 0
tactic: split_ifs with h
Theorem: List.toFinset_cons
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a : α
⊢ (a :: l).toFinset.val = (insert a l.toFinset).val
state_after: no goals
tactic: by_cases h : a ∈ l <;> simp [Finset.insert_val', Multiset.dedup_cons, h]
Theorem: Set.image_eq
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
s : Set α
⊢ f '' s = (Function.graph f).image s
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.Filtration.stronglyMeasurable_limitProcess
File: Mathlib/Probability/Process/Filtration.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
E : Type u_4
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
ℱ : Filtration ι m
f : ι → Ω → E
μ : Measure Ω
⊢ StronglyMeasurable (limitProcess f ℱ μ)
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
E : Type u_4
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
ℱ : Filtration ι m
f : ι → Ω → E
μ : Measure Ω
⊢ StronglyMeasurable
    (if h : ∃ g, StronglyMeasurable g ∧ ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun n => f n ω) atTop (𝓝 (g ω)) then Classical.choose h
    else 0)
tactic: rw [limitProcess]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
E : Type u_4
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
ℱ : Filtration ι m
f : ι → Ω → E
μ : Measure Ω
⊢ StronglyMeasurable
    (if h : ∃ g, StronglyMeasurable g ∧ ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun n => f n ω) atTop (𝓝 (g ω)) then Classical.choose h
    else 0)
state_after: case pos
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
E : Type u_4
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
ℱ : Filtration ι m
f : ι → Ω → E
μ : Measure Ω
h : ∃ g, StronglyMeasurable g ∧ ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun n => f n ω) atTop (𝓝 (g ω))
⊢ StronglyMeasurable (Classical.choose h)

case neg
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
E : Type u_4
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
ℱ : Filtration ι m
f : ι → Ω → E
μ : Measure Ω
h : ¬∃ g, StronglyMeasurable g ∧ ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun n => f n ω) atTop (𝓝 (g ω))
⊢ StronglyMeasurable 0
tactic: split_ifs with h
state_before: case pos
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
E : Type u_4
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
ℱ : Filtration ι m
f : ι → Ω → E
μ : Measure Ω
h : ∃ g, StronglyMeasurable g ∧ ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun n => f n ω) atTop (𝓝 (g ω))
⊢ StronglyMeasurable (Classical.choose h)

case neg
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝⁵ : TopologicalSpace β
inst✝⁴ : MetrizableSpace β
mβ : MeasurableSpace β
inst✝³ : BorelSpace β
inst✝² : Preorder ι
E : Type u_4
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
ℱ : Filtration ι m
f : ι → Ω → E
μ : Measure Ω
h : ¬∃ g, StronglyMeasurable g ∧ ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun n => f n ω) atTop (𝓝 (g ω))
⊢ StronglyMeasurable 0
state_after: no goals
tactic: exacts [(Classical.choose_spec h).1, stronglyMeasurable_zero]
Theorem: MeasureTheory.measure_iUnion₀
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝ : Countable ι
f : ι → Set α
hd : Pairwise (AEDisjoint μ on f)
h : ∀ (i : ι), NullMeasurableSet (f i) μ
⊢ μ (⋃ i, f i) = ∑' (i : ι), μ (f i)
state_after: case intro.intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ : Set α
inst✝ : Countable ι
f : ι → Set α
hd : Pairwise (AEDisjoint μ on f)
h : ∀ (i : ι), NullMeasurableSet (f i) μ
t : ι → Set α
_ht_sub : ∀ (i : ι), t i ⊆ f i
ht_eq : ∀ (i : ι), f i =ᶠ[ae μ] t i
htm : ∀ (i : ι), MeasurableSet (t i)
htd : Pairwise (Disjoint on t)
⊢ μ (⋃ i, f i) = ∑' (i : ι), μ (f i)
tactic: rcases exists_subordinate_pairwise_disjoint h hd with ⟨t, _ht_sub, ht_eq, htm, htd⟩
state_before: case intro.intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t✝ : Set α
inst✝ : Countable ι
f : ι → Set α
hd : Pairwise (AEDisjoint μ on f)
h : ∀ (i : ι), NullMeasurableSet (f i) μ
t : ι → Set α
_ht_sub : ∀ (i : ι), t i ⊆ f i
ht_eq : ∀ (i : ι), f i =ᶠ[ae μ] t i
htm : ∀ (i : ι), MeasurableSet (t i)
htd : Pairwise (Disjoint on t)
⊢ μ (⋃ i, f i) = ∑' (i : ι), μ (f i)
state_after: no goals
tactic: calc
    μ (⋃ i, f i) = μ (⋃ i, t i) := measure_congr (EventuallyEq.countable_iUnion ht_eq)
    _ = ∑' i, μ (t i) := measure_iUnion htd htm
    _ = ∑' i, μ (f i) := tsum_congr fun i => measure_congr (ht_eq _).symm
Theorem: Mathlib.Vector.mOfFn_pure
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n✝ : ℕ
α✝ : Type u_1
m : Type u_2 → Type u_3
inst✝¹ : Monad m
inst✝ : LawfulMonad m
α : Type u_2
n : ℕ
f : Fin (n + 1) → α
⊢ (mOfFn fun i => pure (f i)) = pure (ofFn f)
state_after: n✝ : ℕ
α✝ : Type u_1
m : Type u_2 → Type u_3
inst✝¹ : Monad m
inst✝ : LawfulMonad m
α : Type u_2
n : ℕ
f : Fin (n + 1) → α
⊢ (do
      let a ← pure (f 0)
      let v ← pure (ofFn fun i => f i.succ)
      pure (a ::ᵥ v)) =
    pure (f 0 ::ᵥ ofFn fun i => f i.succ)
tactic: rw [mOfFn, @mOfFn_pure m _ _ _ n _, ofFn]
state_before: n✝ : ℕ
α✝ : Type u_1
m : Type u_2 → Type u_3
inst✝¹ : Monad m
inst✝ : LawfulMonad m
α : Type u_2
n : ℕ
f : Fin (n + 1) → α
⊢ (do
      let a ← pure (f 0)
      let v ← pure (ofFn fun i => f i.succ)
      pure (a ::ᵥ v)) =
    pure (f 0 ::ᵥ ofFn fun i => f i.succ)
state_after: no goals
tactic: simp