ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: OnePoint.not_mem_range_coe_iff
File: Mathlib/Topology/Compactification/OnePoint.lean

Proof steps:
state_before: X : Type u_1
x : OnePoint X
⊢ x ∉ range some ↔ x = ∞
state_after: no goals
tactic: rw [← mem_compl_iff, compl_range_coe, mem_singleton_iff]
Theorem: Complex.re_eq_add_conj
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
⊢ ↑z.re = (z + (starRingEnd ℂ) z) / 2
state_after: no goals
tactic: simp only [add_conj, ofReal_mul, ofReal_ofNat, mul_div_cancel_left₀ (z.re : ℂ) two_ne_zero]
Theorem: right_vsub_midpoint
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z p₁ p₂ : P
⊢ p₂ -ᵥ midpoint R p₁ p₂ = ⅟2 • (p₂ -ᵥ p₁)
state_after: no goals
tactic: rw [midpoint_comm, left_vsub_midpoint]
Theorem: neg_of_add_lt_right
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : MulOneClass α
inst✝¹ : LT α
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
h : a * b < a
⊢ a * b < a * 1
state_after: no goals
tactic: simpa only [mul_one]
Theorem: MonoidAlgebra.prod_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
ι : Type ui
inst✝¹ : CommSemiring k
inst✝ : CommMonoid G
s✝ : Finset ι
a✝ : ι → G
b : ι → k
a : ι
s : Finset ι
has : a ∉ s
ih : ∏ i ∈ s, single (a✝ i) (b i) = single (∏ i ∈ s, a✝ i) (∏ i ∈ s, b i)
⊢ ∏ i ∈ Finset.cons a s has, single (a✝ i) (b i) =
    single (∏ i ∈ Finset.cons a s has, a✝ i) (∏ i ∈ Finset.cons a s has, b i)
state_after: no goals
tactic: rw [prod_cons has, ih, single_mul_single, prod_cons has, prod_cons has]
Theorem: Nat.dist_eq_sub_of_le_right
File: Mathlib/Data/Nat/Dist.lean

Proof steps:
state_before: n m : ℕ
h : m ≤ n
⊢ n.dist m = n - m
state_after: n m : ℕ
h : m ≤ n
⊢ m.dist n = n - m
tactic: rw [dist_comm]
state_before: n m : ℕ
h : m ≤ n
⊢ m.dist n = n - m
state_after: no goals
tactic: apply dist_eq_sub_of_le h
Theorem: Set.preimage_iterate_eq
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g : β → γ
f : α → α
n : ℕ
⊢ preimage f^[n] = (preimage f)^[n]
state_after: case zero
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g : β → γ
f : α → α
⊢ preimage f^[0] = (preimage f)^[0]

case succ
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g : β → γ
f : α → α
n : ℕ
ih : preimage f^[n] = (preimage f)^[n]
⊢ preimage f^[n + 1] = (preimage f)^[n + 1]
tactic: induction' n with n ih
state_before: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g : β → γ
f : α → α
n : ℕ
ih : preimage f^[n] = (preimage f)^[n]
⊢ preimage f^[n + 1] = (preimage f)^[n + 1]
state_after: no goals
tactic: rw [iterate_succ, iterate_succ', preimage_comp_eq, ih]
Theorem: NonAssocRing.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
inst₁ inst₂ : NonAssocRing R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : NonAssocRing R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
tactic: rintro rfl
state_before: R : Type u
inst₁ : NonAssocRing R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
tactic: constructor <;> rfl
Theorem: List.sum_append
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
⊢ (l₁ ++ l₂).prod = foldl (fun x x_1 => x * x_1) (foldl (fun x x_1 => x * x_1) 1 l₁ * 1) l₂
state_after: no goals
tactic: simp [List.prod]
Theorem: _private.Mathlib.GroupTheory.SchurZassenhaus.0.Subgroup.SchurZassenhausInduction.step5
File: Mathlib/GroupTheory/SchurZassenhaus.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Finite G
N : Subgroup G
inst✝ : N.Normal
h1 : (Nat.card ↥N).Coprime N.index
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Finite G'],
    Nat.card G' < Nat.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Nat.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
P : Sylow (Nat.card ↥N).minFac ↥N
⊢ ↑P ≠ ⊥
state_after: G : Type u
inst✝² : Group G
inst✝¹ : Finite G
N : Subgroup G
inst✝ : N.Normal
h1 : (Nat.card ↥N).Coprime N.index
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Finite G'],
    Nat.card G' < Nat.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Nat.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
P : Sylow (Nat.card ↥N).minFac ↥N
this : Fact (Nat.Prime (Nat.card ↥N).minFac)
⊢ ↑P ≠ ⊥
tactic: haveI : Fact (Nat.card N).minFac.Prime := ⟨step4 h1 h3⟩
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Finite G
N : Subgroup G
inst✝ : N.Normal
h1 : (Nat.card ↥N).Coprime N.index
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Finite G'],
    Nat.card G' < Nat.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Nat.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
P : Sylow (Nat.card ↥N).minFac ↥N
this : Fact (Nat.Prime (Nat.card ↥N).minFac)
⊢ ↑P ≠ ⊥
state_after: G : Type u
inst✝² : Group G
inst✝¹ : Finite G
N : Subgroup G
inst✝ : N.Normal
h1 : (Nat.card ↥N).Coprime N.index
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Finite G'],
    Nat.card G' < Nat.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Nat.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
P : Sylow (Nat.card ↥N).minFac ↥N
this : Fact (Nat.Prime (Nat.card ↥N).minFac)
⊢ (Nat.card ↥N).minFac ∣ Nat.card ↥N
tactic: apply P.ne_bot_of_dvd_card
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Finite G
N : Subgroup G
inst✝ : N.Normal
h1 : (Nat.card ↥N).Coprime N.index
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Finite G'],
    Nat.card G' < Nat.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Nat.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
P : Sylow (Nat.card ↥N).minFac ↥N
this : Fact (Nat.Prime (Nat.card ↥N).minFac)
⊢ (Nat.card ↥N).minFac ∣ Nat.card ↥N
state_after: no goals
tactic: exact (Nat.card N).minFac_dvd
Theorem: Mathlib.Tactic.Abel.zero_smulg
File: Mathlib/Tactic/Abel.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
c : ℤ
⊢ smulg c 0 = 0
state_after: no goals
tactic: simp [smulg, zsmul_zero]
Theorem: Finsupp.erase_of_not_mem_support
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α →₀ M
a : α
haf : a ∉ f.support
⊢ erase a f = f
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α →₀ M
a : α
haf : a ∉ f.support
b : α
⊢ (erase a f) b = f b
tactic: ext b
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α →₀ M
a : α
haf : a ∉ f.support
b : α
⊢ (erase a f) b = f b
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α →₀ M
a : α
haf : a ∉ f.support
b : α
hab : b = a
⊢ (erase a f) b = f b

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α →₀ M
a : α
haf : a ∉ f.support
b : α
hab : ¬b = a
⊢ (erase a f) b = f b
tactic: by_cases hab : b = a
Theorem: Complex.abs_cpow_inv_nat
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x : ℂ
n : ℕ
⊢ abs (x ^ (↑n)⁻¹) = abs x ^ (↑n)⁻¹
state_after: x : ℂ
n : ℕ
⊢ abs (x ^ (↑n)⁻¹) = abs (x ^ ↑(↑n)⁻¹)
tactic: rw [← abs_cpow_real]
state_before: x : ℂ
n : ℕ
⊢ abs (x ^ (↑n)⁻¹) = abs (x ^ ↑(↑n)⁻¹)
state_after: no goals
tactic: simp [-abs_cpow_real]
Theorem: IsSeparatedMap.eq_of_comp_eq
File: Mathlib/Topology/SeparatedMap.lean

Proof steps:
state_before: X : Type u_3
Y : ?m.21441
A✝ : Type ?u.21450
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace A✝
E : Type u_1
A : Type u_2
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalSpace A
p : E → X
sep : IsSeparatedMap p
inj : IsLocallyInjective p
s : Set A
hs : IsPreconnected s
g g₁ g₂ : A → E
inst✝ : PreconnectedSpace A
h₁ : Continuous g₁
h₂ : Continuous g₂
he : p ∘ g₁ = p ∘ g₂
a : A
ha : g₁ a = g₂ a
a' : A
⊢ g₁ a' = g₂ a'
state_after: no goals
tactic: apply (IsClopen.eq_univ ⟨sep.isClosed_eqLocus h₁ h₂ he, inj.isOpen_eqLocus h₁ h₂ he⟩ ⟨a, ha⟩).symm
    ▸ Set.mem_univ a'
Theorem: CategoryTheory.Limits.MulticospanIndex.ofPiForkFunctor_map_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
I : MulticospanIndex C
inst✝¹ : HasProduct I.left
inst✝ : HasProduct I.right
K₁ K₂ : Fork I.fstPiMap I.sndPiMap
f : K₁ ⟶ K₂
⊢ ∀ (j : WalkingMulticospan I.fstTo I.sndTo),
    f.hom ≫ (Multifork.ofPiFork I K₂).π.app j = (Multifork.ofPiFork I K₁).π.app j
state_after: no goals
tactic: rintro (_ | _) <;> simp
Theorem: Nat.card_fun
File: Mathlib/SetTheory/Cardinal/Finite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : Finite α
⊢ Nat.card (α → β) = Nat.card β ^ Nat.card α
state_after: α : Type u_1
β : Type u_2
inst✝ : Finite α
this : Fintype α
⊢ Nat.card (α → β) = Nat.card β ^ Nat.card α
tactic: haveI := Fintype.ofFinite α
state_before: α : Type u_1
β : Type u_2
inst✝ : Finite α
this : Fintype α
⊢ Nat.card (α → β) = Nat.card β ^ Nat.card α
state_after: no goals
tactic: rw [Nat.card_pi, Finset.prod_const, Finset.card_univ, ← Nat.card_eq_fintype_card]
Theorem: Option.map₂_map_right
File: Mathlib/Data/Option/NAry.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a : Option α
b : Option β
c : Option γ
f : α → γ → δ
g : β → γ
⊢ map₂ f a (Option.map g b) = map₂ (fun a b => f a (g b)) a b
state_after: no goals
tactic: cases b <;> rfl
Theorem: Finset.sum_condensed_le'
File: Mathlib/Analysis/PSeries.lean

Proof steps:
state_before: M : Type u_1
inst✝ : OrderedAddCommMonoid M
f : ℕ → M
u : ℕ → ℕ
hf : ∀ ⦃m n : ℕ⦄, 1 < m → m ≤ n → f n ≤ f m
n : ℕ
⊢ ∑ k ∈ range n, 2 ^ k • f (2 ^ (k + 1)) ≤ ∑ k ∈ Ico 2 (2 ^ n + 1), f k
state_after: case h.e'_3.a
M : Type u_1
inst✝ : OrderedAddCommMonoid M
f : ℕ → M
u : ℕ → ℕ
hf : ∀ ⦃m n : ℕ⦄, 1 < m → m ≤ n → f n ≤ f m
n x✝ : ℕ
a✝ : x✝ ∈ range n
⊢ 2 ^ x✝ • f (2 ^ (x✝ + 1)) = (2 ^ (x✝ + 1) - 2 ^ x✝) • f (2 ^ (x✝ + 1))
tactic: convert sum_schlomilch_le' hf (fun n => pow_pos zero_lt_two n)
    (fun m n hm => pow_le_pow_right one_le_two hm) n using 2
state_before: case h.e'_3.a
M : Type u_1
inst✝ : OrderedAddCommMonoid M
f : ℕ → M
u : ℕ → ℕ
hf : ∀ ⦃m n : ℕ⦄, 1 < m → m ≤ n → f n ≤ f m
n x✝ : ℕ
a✝ : x✝ ∈ range n
⊢ 2 ^ x✝ • f (2 ^ (x✝ + 1)) = (2 ^ (x✝ + 1) - 2 ^ x✝) • f (2 ^ (x✝ + 1))
state_after: no goals
tactic: simp [pow_succ, mul_two, two_mul]
Theorem: FreeLieAlgebra.lift_of_apply
File: Mathlib/Algebra/Lie/Free.lean

Proof steps:
state_before: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
x : X
⊢ ((lift R) f) (of R x) = f x
state_after: no goals
tactic: rw [← @Function.comp_apply _ _ _ (lift R f) (of R) x, of_comp_lift]
Theorem: CategoryTheory.Limits.prod.diag_map
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ X Y : C
f : X ⟶ Y
inst✝¹ : HasBinaryProduct X X
inst✝ : HasBinaryProduct Y Y
⊢ diag X ≫ map f f = f ≫ diag Y
state_after: no goals
tactic: simp
Theorem: Polynomial.revAtFun_inj
File: Mathlib/Algebra/Polynomial/Reverse.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
N : ℕ
⊢ Function.Injective (revAtFun N)
state_after: R : Type u_1
inst✝ : Semiring R
f : R[X]
N a b : ℕ
hab : revAtFun N a = revAtFun N b
⊢ a = b
tactic: intro a b hab
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
N a b : ℕ
hab : revAtFun N a = revAtFun N b
⊢ a = b
state_after: no goals
tactic: rw [← @revAtFun_invol N a, hab, revAtFun_invol]
Theorem: CategoryTheory.MonoidalCategory.whiskerLeft_comp
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
W X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ W ◁ (f ≫ g) = W ◁ f ≫ W ◁ g
state_after: no goals
tactic: simp only [← id_tensorHom, ← tensor_comp, comp_id]
Theorem: Array.SatisfiesM_mapM
File: .lake/packages/batteries/Batteries/Data/Array/Monadic.lean

Proof steps:
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
as : Array α
f : α → m β
motive : Nat → Prop
h0 : motive 0
p : Fin as.size → β → Prop
hs : ∀ (i : Fin as.size), motive ↑i → SatisfiesM (fun x => p i x ∧ motive (↑i + 1)) (f as[i])
⊢ SatisfiesM (fun arr => motive as.size ∧ ∃ eq, ∀ (i : Nat) (h : i < as.size), p ⟨i, h⟩ arr[i]) (mapM f as)
state_after: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
as : Array α
f : α → m β
motive : Nat → Prop
h0 : motive 0
p : Fin as.size → β → Prop
hs : ∀ (i : Fin as.size), motive ↑i → SatisfiesM (fun x => p i x ∧ motive (↑i + 1)) (f as[i])
⊢ SatisfiesM (fun arr => motive as.size ∧ ∃ eq, ∀ (i : Nat) (h : i < as.size), p ⟨i, h⟩ arr[i])
    (foldlM (fun bs a => bs.push <$> f a) #[] as 0)
tactic: rw [mapM_eq_foldlM]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
as : Array α
f : α → m β
motive : Nat → Prop
h0 : motive 0
p : Fin as.size → β → Prop
hs : ∀ (i : Fin as.size), motive ↑i → SatisfiesM (fun x => p i x ∧ motive (↑i + 1)) (f as[i])
⊢ SatisfiesM (fun arr => motive as.size ∧ ∃ eq, ∀ (i : Nat) (h : i < as.size), p ⟨i, h⟩ arr[i])
    (foldlM (fun bs a => bs.push <$> f a) #[] as 0)
state_after: case z
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
as : Array α
f : α → m β
motive : Nat → Prop
h0 : motive 0
p : Fin as.size → β → Prop
hs : ∀ (i : Fin as.size), motive ↑i → SatisfiesM (fun x => p i x ∧ motive (↑i + 1)) (f as[i])
⊢ (fun i arr => motive i ∧ arr.size = i ∧ ∀ (i : Fin as.size) (h2 : ↑i < arr.size), p i arr[↑i]) 0 #[]

case s
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
as : Array α
f : α → m β
motive : Nat → Prop
h0 : motive 0
p : Fin as.size → β → Prop
hs : ∀ (i : Fin as.size), motive ↑i → SatisfiesM (fun x => p i x ∧ motive (↑i + 1)) (f as[i])
⊢ ∀ (i : Fin as.size) (b : Array β),
    (fun i arr => motive i ∧ arr.size = i ∧ ∀ (i : Fin as.size) (h2 : ↑i < arr.size), p i arr[↑i]) (↑i) b →
      SatisfiesM
        ((fun i arr => motive i ∧ arr.size = i ∧ ∀ (i : Fin as.size) (h2 : ↑i < arr.size), p i arr[↑i]) (↑i + 1))
        (b.push <$> f as[i])
tactic: refine SatisfiesM_foldlM (m := m) (β := Array β)
    (motive := fun i arr => motive i ∧ arr.size = i ∧ ∀ i h2, p i (arr[i.1]'h2)) ?z ?s
    |>.imp fun ⟨h₁, eq, h₂⟩ => ⟨h₁, eq, fun _ _ => h₂ ..⟩
Theorem: Matrix.mul_fromColumns
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₂
inst✝ : Semiring R
A : Matrix m n R
B₁ : Matrix n n₁ R
B₂ : Matrix n n₂ R
⊢ A * B₁.fromColumns B₂ = (A * B₁).fromColumns (A * B₂)
state_after: no goals
tactic: ext _ (_ | _) <;> simp [mul_apply]
Theorem: FormalMultilinearSeries.leftInv_coeff_zero
File: Mathlib/Analysis/Analytic/Inverse.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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
⊢ p.leftInv i 0 = 0
state_after: no goals
tactic: rw [leftInv]
Theorem: Finset.image_subset_iff
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
⊢ image f s ⊆ t ↔ f '' ↑s ⊆ ↑t
state_after: no goals
tactic: norm_cast
Theorem: Multiset.rel_add_left
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
as₀ as₁ : Multiset α
⊢ ∀ {bs : Multiset β}, Rel r (0 + as₁) bs ↔ ∃ bs₀ bs₁, Rel r 0 bs₀ ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
as₀ as₁ : Multiset α
a : α
s : Multiset α
ih : ∀ {bs : Multiset β}, Rel r (s + as₁) bs ↔ ∃ bs₀ bs₁, Rel r s bs₀ ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁
bs : Multiset β
⊢ Rel r (a ::ₘ s + as₁) bs ↔ ∃ bs₀ bs₁, Rel r (a ::ₘ s) bs₀ ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁
state_after: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
as₀ as₁ : Multiset α
a : α
s : Multiset α
ih : ∀ {bs : Multiset β}, Rel r (s + as₁) bs ↔ ∃ bs₀ bs₁, Rel r s bs₀ ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁
bs : Multiset β
⊢ (∃ b bs', r a b ∧ (∃ bs₀ bs₁, Rel r s bs₀ ∧ Rel r as₁ bs₁ ∧ bs' = bs₀ + bs₁) ∧ bs = b ::ₘ bs') ↔
    ∃ bs₀ bs₁, (∃ b bs', r a b ∧ Rel r s bs' ∧ bs₀ = b ::ₘ bs') ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁
tactic: simp only [ih, cons_add, rel_cons_left]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
as₀ as₁ : Multiset α
a : α
s : Multiset α
ih : ∀ {bs : Multiset β}, Rel r (s + as₁) bs ↔ ∃ bs₀ bs₁, Rel r s bs₀ ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁
bs : Multiset β
⊢ (∃ b bs', r a b ∧ (∃ bs₀ bs₁, Rel r s bs₀ ∧ Rel r as₁ bs₁ ∧ bs' = bs₀ + bs₁) ∧ bs = b ::ₘ bs') ↔
    ∃ bs₀ bs₁, (∃ b bs', r a b ∧ Rel r s bs' ∧ bs₀ = b ::ₘ bs') ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁
state_after: case mp
α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
as₀ as₁ : Multiset α
a : α
s : Multiset α
ih : ∀ {bs : Multiset β}, Rel r (s + as₁) bs ↔ ∃ bs₀ bs₁, Rel r s bs₀ ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁
bs : Multiset β
⊢ (∃ b bs', r a b ∧ (∃ bs₀ bs₁, Rel r s bs₀ ∧ Rel r as₁ bs₁ ∧ bs' = bs₀ + bs₁) ∧ bs = b ::ₘ bs') →
    ∃ bs₀ bs₁, (∃ b bs', r a b ∧ Rel r s bs' ∧ bs₀ = b ::ₘ bs') ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁

case mpr
α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
as₀ as₁ : Multiset α
a : α
s : Multiset α
ih : ∀ {bs : Multiset β}, Rel r (s + as₁) bs ↔ ∃ bs₀ bs₁, Rel r s bs₀ ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁
bs : Multiset β
⊢ (∃ bs₀ bs₁, (∃ b bs', r a b ∧ Rel r s bs' ∧ bs₀ = b ::ₘ bs') ∧ Rel r as₁ bs₁ ∧ bs = bs₀ + bs₁) →
    ∃ b bs', r a b ∧ (∃ bs₀ bs₁, Rel r s bs₀ ∧ Rel r as₁ bs₁ ∧ bs' = bs₀ + bs₁) ∧ bs = b ::ₘ bs'
tactic: constructor
Theorem: CategoryTheory.Preadditive.mono_iff_injective
File: Mathlib/Algebra/Homology/ShortComplex/ConcreteCategory.lean

Proof steps:
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : ConcreteCategory C
inst✝⁴ : HasForget₂ C Ab
inst✝³ : Preadditive C
inst✝² : (forget₂ C Ab).Additive
inst✝¹ : (forget₂ C Ab).PreservesHomology
inst✝ : HasZeroObject C
S : ShortComplex C
X Y : C
f : X ⟶ Y
⊢ Mono f ↔ Function.Injective ⇑((forget₂ C Ab).map f)
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : ConcreteCategory C
inst✝⁴ : HasForget₂ C Ab
inst✝³ : Preadditive C
inst✝² : (forget₂ C Ab).Additive
inst✝¹ : (forget₂ C Ab).PreservesHomology
inst✝ : HasZeroObject C
S : ShortComplex C
X Y : C
f : X ⟶ Y
⊢ Mono f ↔ Mono ((forget₂ C Ab).map f)
tactic: rw [← AddCommGrp.mono_iff_injective]
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : ConcreteCategory C
inst✝⁴ : HasForget₂ C Ab
inst✝³ : Preadditive C
inst✝² : (forget₂ C Ab).Additive
inst✝¹ : (forget₂ C Ab).PreservesHomology
inst✝ : HasZeroObject C
S : ShortComplex C
X Y : C
f : X ⟶ Y
⊢ Mono f ↔ Mono ((forget₂ C Ab).map f)
state_after: case mp
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : ConcreteCategory C
inst✝⁴ : HasForget₂ C Ab
inst✝³ : Preadditive C
inst✝² : (forget₂ C Ab).Additive
inst✝¹ : (forget₂ C Ab).PreservesHomology
inst✝ : HasZeroObject C
S : ShortComplex C
X Y : C
f : X ⟶ Y
⊢ Mono f → Mono ((forget₂ C Ab).map f)

case mpr
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : ConcreteCategory C
inst✝⁴ : HasForget₂ C Ab
inst✝³ : Preadditive C
inst✝² : (forget₂ C Ab).Additive
inst✝¹ : (forget₂ C Ab).PreservesHomology
inst✝ : HasZeroObject C
S : ShortComplex C
X Y : C
f : X ⟶ Y
⊢ Mono ((forget₂ C Ab).map f) → Mono f
tactic: constructor
Theorem: subalgebra_top_finrank_eq_submodule_top_finrank
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

Proof steps:
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring R
inst✝⁹ : CommRing S
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
F : Type u_2
E : Type u_3
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ finrank F ↥⊤ = finrank F ↥⊤
state_after: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring R
inst✝⁹ : CommRing S
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
F : Type u_2
E : Type u_3
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ finrank F ↥⊤ = finrank F ↥(Subalgebra.toSubmodule ⊤)
tactic: rw [← Algebra.top_toSubmodule]
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring R
inst✝⁹ : CommRing S
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
F : Type u_2
E : Type u_3
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ finrank F ↥⊤ = finrank F ↥(Subalgebra.toSubmodule ⊤)
state_after: no goals
tactic: rfl
Theorem: Multiset.aestronglyMeasurable_sum
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
s : Multiset (α → M)
hs : ∀ f ∈ s, AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable (fun x => (Multiset.map (fun f => f x) s).prod) μ
state_after: no goals
tactic: simpa only [← Pi.multiset_prod_apply] using s.aestronglyMeasurable_prod' hs
Theorem: Filter.HasBasis.sup_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' : ι'
hl : l.HasBasis p s
x : α
⊢ (l ⊔ pure x).HasBasis p fun i => s i ∪ {x}
state_after: no goals
tactic: simp only [← principal_singleton, hl.sup_principal]