ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.prod_le_prod
File: Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
inst✝³ : CommMonoidWithZero R
inst✝² : PartialOrder R
inst✝¹ : ZeroLEOneClass R
inst✝ : PosMulMono R
f g : ι → R
s t : Finset ι
h0 : ∀ i ∈ s, 0 ≤ f i
h1 : ∀ i ∈ s, f i ≤ g i
⊢ ∏ i ∈ s, f i ≤ ∏ i ∈ s, g i
state_after: case empty
ι : Type u_1
R : Type u_2
inst✝³ : CommMonoidWithZero R
inst✝² : PartialOrder R
inst✝¹ : ZeroLEOneClass R
inst✝ : PosMulMono R
f g : ι → R
s t : Finset ι
h0 : ∀ i ∈ ∅, 0 ≤ f i
h1 : ∀ i ∈ ∅, f i ≤ g i
⊢ ∏ i ∈ ∅, f i ≤ ∏ i ∈ ∅, g i

case cons
ι : Type u_1
R : Type u_2
inst✝³ : CommMonoidWithZero R
inst✝² : PartialOrder R
inst✝¹ : ZeroLEOneClass R
inst✝ : PosMulMono R
f g : ι → R
s✝ t : Finset ι
a : ι
s : Finset ι
has : a ∉ s
ih : (∀ i ∈ s, 0 ≤ f i) → (∀ i ∈ s, f i ≤ g i) → ∏ i ∈ s, f i ≤ ∏ i ∈ s, g i
h0 : ∀ i ∈ cons a s has, 0 ≤ f i
h1 : ∀ i ∈ cons a s has, f i ≤ g i
⊢ ∏ i ∈ cons a s has, f i ≤ ∏ i ∈ cons a s has, g i
tactic: induction' s using Finset.cons_induction with a s has ih h
Theorem: CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_unitIso
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 : Multifork I
⊢ ∀ (j : WalkingMulticospan I.fstTo I.sndTo),
    ((𝟭 (Multifork I)).obj K).π.app j =
      (Iso.refl ((𝟭 (Multifork I)).obj K).pt).hom ≫ ((I.toPiForkFunctor ⋙ I.ofPiForkFunctor).obj K).π.app j
state_after: no goals
tactic: rintro (_ | _) <;> simp [← Fork.app_one_eq_ι_comp_left]
Theorem: Sum.Lex.Ioo_inl_inl
File: Mathlib/Data/Sum/Interval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioo (inlₗ a₁) (inlₗ a₂) = map (Embedding.inl.trans toLex.toEmbedding) (Ioo a₁ a₂)
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioo (inlₗ a₁) (inlₗ a₂) = map toLex.toEmbedding (map Embedding.inl (Ioo a₁ a₂))
tactic: rw [← Finset.map_map]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioo (inlₗ a₁) (inlₗ a₂) = map toLex.toEmbedding (map Embedding.inl (Ioo a₁ a₂))
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.Lp.norm_le_mul_norm_of_ae_le_mul
File: Mathlib/MeasureTheory/Function/LpSpace.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
c : ℝ
f : ↥(Lp E p μ)
g : ↥(Lp F p μ)
h : ∀ᵐ (x : α) ∂μ, ‖↑↑f x‖ ≤ c * ‖↑↑g x‖
⊢ ‖f‖ ≤ c * ‖g‖
state_after: case inl
α : 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
c : ℝ
f : ↥(Lp E p μ)
g : ↥(Lp F p μ)
h : ∀ᵐ (x : α) ∂μ, ‖↑↑f x‖ ≤ c * ‖↑↑g x‖
hc : 0 ≤ c
⊢ ‖f‖ ≤ c * ‖g‖

case inr
α : 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
c : ℝ
f : ↥(Lp E p μ)
g : ↥(Lp F p μ)
h : ∀ᵐ (x : α) ∂μ, ‖↑↑f x‖ ≤ c * ‖↑↑g x‖
hc : c < 0
⊢ ‖f‖ ≤ c * ‖g‖
tactic: rcases le_or_lt 0 c with hc | hc
Theorem: Filter.IsBoundedUnder.bddAbove_range
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : ℕ → β
hf : IsBoundedUnder (fun x x_1 => x ≤ x_1) atTop f
⊢ BddAbove (range f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : ℕ → β
hf : IsBoundedUnder (fun x x_1 => x ≤ x_1) cofinite f
⊢ BddAbove (range f)
tactic: rw [← Nat.cofinite_eq_atTop] at hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : ℕ → β
hf : IsBoundedUnder (fun x x_1 => x ≤ x_1) cofinite f
⊢ BddAbove (range f)
state_after: no goals
tactic: exact hf.bddAbove_range_of_cofinite
Theorem: sub_zsmul
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
m n : ℤ
⊢ a ^ (m - n) = a ^ m * (a ^ n)⁻¹
state_after: no goals
tactic: rw [Int.sub_eq_add_neg, zpow_add, zpow_neg]
Theorem: Algebra.left_comm
File: Mathlib/Algebra/Algebra/Defs.lean

Proof steps:
state_before: R : Type u
S : Type v
A : Type w
B : Type u_1
inst✝⁵ : CommSemiring R
inst✝⁴ : CommSemiring S
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
x : A
r : R
y : A
⊢ x * ((algebraMap R A) r * y) = (algebraMap R A) r * (x * y)
state_after: no goals
tactic: rw [← mul_assoc, ← commutes, mul_assoc]
Theorem: Cardinal.pow_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: κ μ : Cardinal.{u}
H1✝ : ℵ₀ ≤ κ
H2 : μ < ℵ₀
n : ℕ
H3 : μ = ↑n
α : Type u
H1 : ℵ₀ ≤ ⟦α⟧
⊢ ⟦α⟧ ^ ↑Nat.zero < ℵ₀
state_after: κ μ : Cardinal.{u}
H1✝ : ℵ₀ ≤ κ
H2 : μ < ℵ₀
n : ℕ
H3 : μ = ↑n
α : Type u
H1 : ℵ₀ ≤ ⟦α⟧
⊢ 1 < ℵ₀
tactic: rw [Nat.cast_zero, power_zero]
state_before: κ μ : Cardinal.{u}
H1✝ : ℵ₀ ≤ κ
H2 : μ < ℵ₀
n : ℕ
H3 : μ = ↑n
α : Type u
H1 : ℵ₀ ≤ ⟦α⟧
⊢ 1 < ℵ₀
state_after: no goals
tactic: exact one_lt_aleph0
state_before: κ μ : Cardinal.{u}
H1✝ : ℵ₀ ≤ κ
H2 : μ < ℵ₀
n✝ : ℕ
H3 : μ = ↑n✝
α : Type u
H1 : ℵ₀ ≤ ⟦α⟧
n : ℕ
ih : ⟦α⟧ ^ ↑n ≤ ⟦α⟧
⊢ ⟦α⟧ ^ ↑n.succ ≤ ⟦α⟧ * ⟦α⟧
state_after: κ μ : Cardinal.{u}
H1✝ : ℵ₀ ≤ κ
H2 : μ < ℵ₀
n✝ : ℕ
H3 : μ = ↑n✝
α : Type u
H1 : ℵ₀ ≤ ⟦α⟧
n : ℕ
ih : ⟦α⟧ ^ ↑n ≤ ⟦α⟧
⊢ ⟦α⟧ ^ ↑n * ⟦α⟧ ≤ ⟦α⟧ * ⟦α⟧
tactic: rw [Nat.cast_succ, power_add, power_one]
state_before: κ μ : Cardinal.{u}
H1✝ : ℵ₀ ≤ κ
H2 : μ < ℵ₀
n✝ : ℕ
H3 : μ = ↑n✝
α : Type u
H1 : ℵ₀ ≤ ⟦α⟧
n : ℕ
ih : ⟦α⟧ ^ ↑n ≤ ⟦α⟧
⊢ ⟦α⟧ ^ ↑n * ⟦α⟧ ≤ ⟦α⟧ * ⟦α⟧
state_after: no goals
tactic: exact mul_le_mul_right' ih _
Theorem: one_div_zpow
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
n : ℤ
⊢ (1 / a) ^ n = 1 / a ^ n
state_after: no goals
tactic: simp only [one_div, inv_zpow]
Theorem: PresheafOfModules.restrictionApp_comp
File: Mathlib/Algebra/Category/ModuleCat/Presheaf.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
R : Cᵒᵖ ⥤ RingCat
M : PresheafOfModules R
X Y Z : Cᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
⊢ restrictionApp (f ≫ g) M =
    restrictionApp f M ≫
      (ModuleCat.restrictScalars (R.map f)).map (restrictionApp g M) ≫
        (ModuleCat.restrictScalarsComp' (R.map f) (R.map g) (R.map (f ≫ g)) ⋯).inv.app (M.obj Z)
state_after: no goals
tactic: aesop
Theorem: AddMonoidHom.addSubgroupOf_range_eq_of_le
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
G₁ : Type u_7
G₂ : Type u_8
inst✝¹ : Group G₁
inst✝ : Group G₂
K : Subgroup G₂
f : G₁ →* G₂
h : f.range ≤ K
⊢ f.range.subgroupOf K = (f.codRestrict K ⋯).range
state_after: case h
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
G₁ : Type u_7
G₂ : Type u_8
inst✝¹ : Group G₁
inst✝ : Group G₂
K : Subgroup G₂
f : G₁ →* G₂
h : f.range ≤ K
k : ↥K
⊢ k ∈ f.range.subgroupOf K ↔ k ∈ (f.codRestrict K ⋯).range
tactic: ext k
state_before: case h
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
G₁ : Type u_7
G₂ : Type u_8
inst✝¹ : Group G₁
inst✝ : Group G₂
K : Subgroup G₂
f : G₁ →* G₂
h : f.range ≤ K
k : ↥K
⊢ k ∈ f.range.subgroupOf K ↔ k ∈ (f.codRestrict K ⋯).range
state_after: case h
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
G₁ : Type u_7
G₂ : Type u_8
inst✝¹ : Group G₁
inst✝ : Group G₂
K : Subgroup G₂
f : G₁ →* G₂
h : f.range ≤ K
k : ↥K
⊢ ∀ (a : G₁), f a = K.subtype k ↔ (f.codRestrict K ⋯) a = k
tactic: refine exists_congr ?_
state_before: case h
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
G₁ : Type u_7
G₂ : Type u_8
inst✝¹ : Group G₁
inst✝ : Group G₂
K : Subgroup G₂
f : G₁ →* G₂
h : f.range ≤ K
k : ↥K
⊢ ∀ (a : G₁), f a = K.subtype k ↔ (f.codRestrict K ⋯) a = k
state_after: no goals
tactic: simp [Subtype.ext_iff]
Theorem: MvPolynomial.pderiv_X
File: Mathlib/Algebra/MvPolynomial/PDeriv.lean

Proof steps:
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : DecidableEq σ
i j : σ
⊢ (pderiv i) (X j) = Pi.single i 1 j
state_after: no goals
tactic: rw [pderiv_def, mkDerivation_X]
Theorem: AddMonoidAlgebra.single_zero_mul_apply
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : AddZeroClass G
f : k[G]
r : k
x a : G
⊢ 0 + a = x ↔ a = x
state_after: no goals
tactic: rw [zero_add]
Theorem: MvPolynomial.support_finSuccEquiv_nonempty
File: Mathlib/Algebra/MvPolynomial/Equiv.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
h : f ≠ 0
⊢ ((finSuccEquiv R n) f).support.Nonempty
state_after: no goals
tactic: rwa [Polynomial.support_nonempty, AddEquivClass.map_ne_zero_iff]
Theorem: Num.ofNat'_succ
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
⊢ ofNat' (0 + 1) = ofNat' 0 + 1
state_after: no goals
tactic: simp [zero_add]
state_before: α : Type u_1
b : Bool
n : ℕ
ih : ofNat' (n + 1) = ofNat' n + 1
⊢ ofNat' (Nat.bit b n + 1) = ofNat' (Nat.bit b n) + 1
state_after: case false
α : Type u_1
n : ℕ
ih : ofNat' (n + 1) = ofNat' n + 1
⊢ ofNat' (Nat.bit false n + 1) = ofNat' (Nat.bit false n) + 1

case true
α : Type u_1
n : ℕ
ih : ofNat' (n + 1) = ofNat' n + 1
⊢ ofNat' (Nat.bit true n + 1) = ofNat' (Nat.bit true n) + 1
tactic: cases b
Theorem: GaloisConnection.l_ciSup
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝² : ConditionallyCompleteLattice α
inst✝¹ : ConditionallyCompleteLattice β
inst✝ : Nonempty ι
l : α → β
u : β → α
gc : GaloisConnection l u
f : ι → α
hf : BddAbove (range f)
⊢ l (⨆ i, f i) = ⨆ i, l (f i)
state_after: no goals
tactic: rw [iSup, gc.l_csSup (range_nonempty _) hf, iSup_range']
Theorem: Ordinal.unbounded_of_unbounded_sUnion
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
⊢ ∃ x ∈ s, Unbounded r x
state_after: α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ x ∈ s, ¬Unbounded r x
⊢ False
tactic: by_contra! h
state_before: α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ x ∈ s, ¬Unbounded r x
⊢ False
state_after: α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ x ∈ s, Bounded r x
⊢ False
tactic: simp_rw [not_unbounded_iff] at h
state_before: α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ x ∈ s, Bounded r x
⊢ False
state_after: α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ x ∈ s, Bounded r x
f : ↑s → α := fun x => ⋯.sup ↑x ⋯
⊢ False
tactic: let f : s → α := fun x : s => wo.wf.sup x (h x.1 x.2)
state_before: α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ x ∈ s, Bounded r x
f : ↑s → α := fun x => ⋯.sup ↑x ⋯
⊢ False
state_after: α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ x ∈ s, Bounded r x
f : ↑s → α := fun x => ⋯.sup ↑x ⋯
x : α
⊢ ∃ b ∈ range f, swap rᶜ x b
tactic: refine h₂.not_le (le_trans (csInf_le' ⟨range f, fun x => ?_, rfl⟩) mk_range_le)
state_before: α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ x ∈ s, Bounded r x
f : ↑s → α := fun x => ⋯.sup ↑x ⋯
x : α
⊢ ∃ b ∈ range f, swap rᶜ x b
state_after: case intro.intro.intro.intro
α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ x ∈ s, Bounded r x
f : ↑s → α := fun x => ⋯.sup ↑x ⋯
x y : α
hxy : ¬r y x
c : Set α
hc : c ∈ s
hy : y ∈ c
⊢ ∃ b ∈ range f, swap rᶜ x b
tactic: rcases h₁ x with ⟨y, ⟨c, hc, hy⟩, hxy⟩
state_before: case intro.intro.intro.intro
α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ x ∈ s, Bounded r x
f : ↑s → α := fun x => ⋯.sup ↑x ⋯
x y : α
hxy : ¬r y x
c : Set α
hc : c ∈ s
hy : y ∈ c
⊢ ∃ b ∈ range f, swap rᶜ x b
state_after: no goals
tactic: exact ⟨f ⟨c, hc⟩, mem_range_self _, fun hxz => hxy (Trans.trans (wo.wf.lt_sup _ hy) hxz)⟩
Theorem: Basis.noZeroSMulDivisors
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : 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
V : Type u
V' : Type u_9
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b✝ b₁ : Basis ι R M
i : ι
c✝ : R
x✝ : M
inst✝ : NoZeroDivisors R
b : Basis ι R M
c : R
x : M
hcx : c • x = 0
⊢ c = 0 ∨ x = 0
state_after: no goals
tactic: exact or_iff_not_imp_right.mpr fun hx => by
      rw [← b.total_repr x, ← LinearMap.map_smul] at hcx
      have := linearIndependent_iff.mp b.linearIndependent (c • b.repr x) hcx
      rw [smul_eq_zero] at this
      exact this.resolve_right fun hr => hx (b.repr.map_eq_zero_iff.mp hr)
Theorem: WittVector.init_add
File: Mathlib/RingTheory/WittVector/InitTail.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n✝ : ℕ
R : Type u_1
inst✝ : CommRing R
x y : 𝕎 R
n : ℕ
⊢ init n (x + y) = init n (init n x + init n y)
state_after: no goals
tactic: init_ring using wittAdd_vars
Theorem: Pi.isCompact_closure_iff
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝⁵ : TopologicalSpace X
inst✝⁴ : FirstCountableTopology X
Z : Type u_3
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
ι : Type u_4
π : ι → Type u_5
inst✝¹ : (i : ι) → TopologicalSpace (π i)
inst✝ : ∀ (i : ι), T2Space (π i)
s : Set ((i : ι) → π i)
⊢ IsCompact (closure s) ↔ ∀ (i : ι), IsCompact (closure (eval i '' s))
state_after: no goals
tactic: simp_rw [← exists_isCompact_superset_iff, Pi.exists_compact_superset_iff, image_subset_iff]
Theorem: aestronglyMeasurable_of_tendsto_ae
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✝ : α → β
ι : Type u_5
inst✝² : PseudoMetrizableSpace β
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → β
g : α → β
hf : ∀ (i : ι), AEStronglyMeasurable (f i) μ
lim : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => f n x) u (𝓝 (g x))
⊢ AEStronglyMeasurable g μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι✝ : Type u_4
inst✝⁵ : Countable ι✝
m : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f✝ g✝ : α → β
ι : Type u_5
inst✝² : PseudoMetrizableSpace β
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → β
g : α → β
hf : ∀ (i : ι), AEStronglyMeasurable (f i) μ
lim : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => f n x) u (𝓝 (g x))
this✝¹ : MeasurableSpace β := borel β
this✝ : BorelSpace β
⊢ AEStronglyMeasurable g μ
tactic: borelize β
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✝ : α → β
ι : Type u_5
inst✝² : PseudoMetrizableSpace β
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → β
g : α → β
hf : ∀ (i : ι), AEStronglyMeasurable (f i) μ
lim : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => f n x) u (𝓝 (g x))
this✝¹ : MeasurableSpace β := borel β
this✝ : BorelSpace β
⊢ AEStronglyMeasurable g μ
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
ι✝ : Type u_4
inst✝⁵ : Countable ι✝
m : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f✝ g✝ : α → β
ι : Type u_5
inst✝² : PseudoMetrizableSpace β
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → β
g : α → β
hf : ∀ (i : ι), AEStronglyMeasurable (f i) μ
lim : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => f n x) u (𝓝 (g x))
this✝¹ : MeasurableSpace β := borel β
this✝ : BorelSpace β
⊢ AEMeasurable g μ

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
ι✝ : Type u_4
inst✝⁵ : Countable ι✝
m : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f✝ g✝ : α → β
ι : Type u_5
inst✝² : PseudoMetrizableSpace β
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → β
g : α → β
hf : ∀ (i : ι), AEStronglyMeasurable (f i) μ
lim : ∀ᵐ (x : α) ∂μ, Tendsto (fun n => f n x) u (𝓝 (g x))
this✝¹ : MeasurableSpace β := borel β
this✝ : BorelSpace β
⊢ ∃ t, IsSeparable t ∧ ∀ᵐ (x : α) ∂μ, g x ∈ t
tactic: refine aestronglyMeasurable_iff_aemeasurable_separable.2 ⟨?_, ?_⟩
Theorem: Finset.sup_induction
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
p : α → Prop
hb : p ⊥
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
⊢ p (s.sup f)
state_after: no goals
tactic: induction s using Finset.cons_induction with
  | empty => exact hb
  | cons _ _ _ ih =>
    simp only [sup_cons, forall_mem_cons] at hs ⊢
    exact hp _ hs.1 _ (ih hs.2)
Theorem: QuaternionAlgebra.swapEquiv_apply_re
File: Mathlib/Algebra/Quaternion.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c x✝ : ℍ[R,c₁,c₂]
⊢ (fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK })
      ((fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK }) x✝) =
    x✝
state_after: no goals
tactic: simp
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
x✝ : ℍ[R,c₂,c₁]
⊢ (fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK })
      ((fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK }) x✝) =
    x✝
state_after: no goals
tactic: simp
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ { toFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK },
          invFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK }, left_inv := ⋯,
          right_inv := ⋯ }.toFun
      (x✝¹ * x✝) =
    { toFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK },
            invFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK }, left_inv := ⋯,
            right_inv := ⋯ }.toFun
        x✝¹ *
      { toFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK },
            invFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK }, left_inv := ⋯,
            right_inv := ⋯ }.toFun
        x✝
state_after: no goals
tactic: ext
      <;> simp only [mul_re, mul_imJ, mul_imI, add_left_inj, mul_imK, neg_mul, neg_add_rev,
                     neg_sub, mk_mul_mk, mul_neg, neg_neg, sub_neg_eq_add]
      <;> ring
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ { toFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK },
          invFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK }, left_inv := ⋯,
          right_inv := ⋯ }.toFun
      (x✝¹ + x✝) =
    { toFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK },
            invFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK }, left_inv := ⋯,
            right_inv := ⋯ }.toFun
        x✝¹ +
      { toFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK },
            invFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK }, left_inv := ⋯,
            right_inv := ⋯ }.toFun
        x✝
state_after: no goals
tactic: ext <;> simp [add_comm]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
x✝ : R
⊢ { toFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK },
          invFun := fun t => { re := t.re, imI := t.imJ, imJ := t.imI, imK := -t.imK }, left_inv := ⋯,
          right_inv := ⋯ }.toFun
      ((algebraMap R ℍ[R,c₁,c₂]) x✝) =
    (algebraMap R ℍ[R,c₂,c₁]) x✝
state_after: no goals
tactic: simp [algebraMap_eq]
Theorem: MeasureTheory.FiniteMeasure.map_snd_prod
File: Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
⊢ (μ.prod ν).map Prod.snd = μ univ • ν
state_after: case h
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ ↑((μ.prod ν).map Prod.snd) s✝ = ↑(μ univ • ν) s✝
tactic: ext
state_before: case h
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ ↑((μ.prod ν).map Prod.snd) s✝ = ↑(μ univ • ν) s✝
state_after: no goals
tactic: simp