ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ModuleCat.free_shortExact_rank_add
File: Mathlib/Algebra/Category/ModuleCat/Free.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
inst✝³ : Ring R
S : ShortComplex (ModuleCat R)
hS : S.Exact
hS' : S.ShortExact
v : ι → ↑S.X₁
inst✝² : Module.Free R ↑S.X₁
inst✝¹ : Module.Free R ↑S.X₃
inst✝ : StrongRankCondition R
⊢ Module.rank R ↑S.X₂ = Module.rank R ↑S.X₁ + Module.rank R ↑S.X₃
state_after: ι : Type u_1
ι' : Type u_2
R : Type u_3
inst✝³ : Ring R
S : ShortComplex (ModuleCat R)
hS : S.Exact
hS' : S.ShortExact
v : ι → ↑S.X₁
inst✝² : Module.Free R ↑S.X₁
inst✝¹ : Module.Free R ↑S.X₃
inst✝ : StrongRankCondition R
this : Module.Free R ↑S.X₂
⊢ Module.rank R ↑S.X₂ = Module.rank R ↑S.X₁ + Module.rank R ↑S.X₃
tactic: haveI := free_shortExact hS'
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
inst✝³ : Ring R
S : ShortComplex (ModuleCat R)
hS : S.Exact
hS' : S.ShortExact
v : ι → ↑S.X₁
inst✝² : Module.Free R ↑S.X₁
inst✝¹ : Module.Free R ↑S.X₃
inst✝ : StrongRankCondition R
this : Module.Free R ↑S.X₂
⊢ Module.rank R ↑S.X₂ = Module.rank R ↑S.X₁ + Module.rank R ↑S.X₃
state_after: ι : Type u_1
ι' : Type u_2
R : Type u_3
inst✝³ : Ring R
S : ShortComplex (ModuleCat R)
hS : S.Exact
hS' : S.ShortExact
v : ι → ↑S.X₁
inst✝² : Module.Free R ↑S.X₁
inst✝¹ : Module.Free R ↑S.X₃
inst✝ : StrongRankCondition R
this : Module.Free R ↑S.X₂
⊢ Nonempty
    (Module.Free.ChooseBasisIndex R ↑S.X₂ ≃ Module.Free.ChooseBasisIndex R ↑S.X₁ ⊕ Module.Free.ChooseBasisIndex R ↑S.X₃)
tactic: rw [Module.Free.rank_eq_card_chooseBasisIndex, Module.Free.rank_eq_card_chooseBasisIndex R S.X₁,
    Module.Free.rank_eq_card_chooseBasisIndex R S.X₃, Cardinal.add_def, Cardinal.eq]
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
inst✝³ : Ring R
S : ShortComplex (ModuleCat R)
hS : S.Exact
hS' : S.ShortExact
v : ι → ↑S.X₁
inst✝² : Module.Free R ↑S.X₁
inst✝¹ : Module.Free R ↑S.X₃
inst✝ : StrongRankCondition R
this : Module.Free R ↑S.X₂
⊢ Nonempty
    (Module.Free.ChooseBasisIndex R ↑S.X₂ ≃ Module.Free.ChooseBasisIndex R ↑S.X₁ ⊕ Module.Free.ChooseBasisIndex R ↑S.X₃)
state_after: no goals
tactic: exact ⟨Basis.indexEquiv (Module.Free.chooseBasis R S.X₂) (Basis.ofShortExact hS'
    (Module.Free.chooseBasis R S.X₁) (Module.Free.chooseBasis R S.X₃))⟩
Theorem: Localization.r_iff_oreEqv_r
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x y : M × ↥S
⊢ (r S) x y ↔ Setoid.r x y
state_after: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x y : M × ↥S
⊢ (∃ a ∈ S, a * (↑y.2 * x.1) = a * (↑x.2 * y.1)) ↔ ∃ a ∈ S, ∃ v, a * y.1 = v * x.1 ∧ a * ↑y.2 = v * ↑x.2
tactic: simp only [r_iff_exists, Subtype.exists, exists_prop, OreLocalization.oreEqv, smul_eq_mul,
    Submonoid.mk_smul]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x y : M × ↥S
⊢ (∃ a ∈ S, a * (↑y.2 * x.1) = a * (↑x.2 * y.1)) ↔ ∃ a ∈ S, ∃ v, a * y.1 = v * x.1 ∧ a * ↑y.2 = v * ↑x.2
state_after: case mp
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x y : M × ↥S
⊢ (∃ a ∈ S, a * (↑y.2 * x.1) = a * (↑x.2 * y.1)) → ∃ a ∈ S, ∃ v, a * y.1 = v * x.1 ∧ a * ↑y.2 = v * ↑x.2

case mpr
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x y : M × ↥S
⊢ (∃ a ∈ S, ∃ v, a * y.1 = v * x.1 ∧ a * ↑y.2 = v * ↑x.2) → ∃ a ∈ S, a * (↑y.2 * x.1) = a * (↑x.2 * y.1)
tactic: constructor
Theorem: Set.indicator_apply_ne_zero
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a✝ a : α
⊢ s.mulIndicator f a ≠ 1 ↔ a ∈ s ∩ mulSupport f
state_after: no goals
tactic: simp only [Ne, mulIndicator_apply_eq_one, Classical.not_imp, mem_inter_iff, mem_mulSupport]
Theorem: separableClosure.comap_eq_of_algHom
File: Mathlib/FieldTheory/SeparableClosure.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
i : E →ₐ[F] K
⊢ comap i (separableClosure F K) = separableClosure F E
state_after: case h
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
i : E →ₐ[F] K
x : E
⊢ x ∈ comap i (separableClosure F K) ↔ x ∈ separableClosure F E
tactic: ext x
state_before: case h
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
i : E →ₐ[F] K
x : E
⊢ x ∈ comap i (separableClosure F K) ↔ x ∈ separableClosure F E
state_after: no goals
tactic: exact map_mem_separableClosure_iff i
Theorem: Complex.GammaIntegral_convergent
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

Proof steps:
state_before: s : ℂ
hs : 0 < s.re
⊢ IntegrableOn (fun x => ↑(rexp (-x)) * ↑x ^ (s - 1)) (Ioi 0) volume
state_after: case left
s : ℂ
hs : 0 < s.re
⊢ AEStronglyMeasurable (fun x => ↑(rexp (-x)) * ↑x ^ (s - 1)) (volume.restrict (Ioi 0))

case right
s : ℂ
hs : 0 < s.re
⊢ HasFiniteIntegral (fun x => ↑(rexp (-x)) * ↑x ^ (s - 1)) (volume.restrict (Ioi 0))
tactic: constructor
Theorem: EReal.mul_div_right
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: a b c : EReal
⊢ a / b * c = a * c / b
state_after: no goals
tactic: rw [mul_comm, EReal.mul_div, mul_comm]
Theorem: AkraBazziRecurrence.growsPolynomially_deriv_rpow_p_mul_one_sub_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
p : ℝ
⊢ GrowsPolynomially fun x => ‖deriv (fun z => z ^ p * (1 - ε z)) x‖
state_after: no goals
tactic: cases eq_or_ne p 0 with
  | inl hp => -- p = 0
    have h₁ : (fun x => ‖deriv (fun z => z ^ p * (1 - ε z)) x‖)
        =ᶠ[atTop] fun z => z⁻¹ / (log z ^ 2) := by
      filter_upwards [eventually_deriv_one_sub_smoothingFn, eventually_gt_atTop 1] with x hx hx_pos
      have : 0 ≤ x⁻¹ / (log x ^ 2) := by
        have hlog : 0 < log x := Real.log_pos hx_pos
        positivity
      simp only [hp, Real.rpow_zero, one_mul, differentiableAt_const, hx, Real.norm_of_nonneg this]
    refine GrowsPolynomially.congr_of_eventuallyEq h₁ ?_
    refine GrowsPolynomially.div (GrowsPolynomially.inv growsPolynomially_id)
      (GrowsPolynomially.pow 2 growsPolynomially_log ?_)
    filter_upwards [eventually_ge_atTop 1] with _ hx
    exact log_nonneg hx
  | inr hp => -- p ≠ 0
    refine GrowsPolynomially.of_isTheta (growsPolynomially_rpow (p-1))
      (isTheta_deriv_rpow_p_mul_one_sub_smoothingFn hp) ?_
    filter_upwards [eventually_gt_atTop 0] with _ _
    positivity
Theorem: Nat.modEq_nine_digits_sum
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ n : ℕ
⊢ 10 % 9 = 1
state_after: no goals
tactic: norm_num
Theorem: Matrix.cramer_row_self
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

Proof steps:
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
i : n
h : ∀ (j : n), b j = A j i
⊢ A.cramer b = Pi.single i A.det
state_after: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
i : n
h : ∀ (j : n), b j = A j i
⊢ Aᵀᵀ.cramer b = Pi.single i Aᵀ.det
tactic: rw [← transpose_transpose A, det_transpose]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
i : n
h : ∀ (j : n), b j = A j i
⊢ Aᵀᵀ.cramer b = Pi.single i Aᵀ.det
state_after: case h.e'_2.h.e'_6
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
i : n
h : ∀ (j : n), b j = A j i
⊢ b = Aᵀ i
tactic: convert cramer_transpose_row_self Aᵀ i
state_before: case h.e'_2.h.e'_6
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
i : n
h : ∀ (j : n), b j = A j i
⊢ b = Aᵀ i
state_after: no goals
tactic: exact funext h
Theorem: AddChar.inv_mulShift
File: Mathlib/Algebra/Group/AddChar.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
⊢ ψ⁻¹ = ψ.mulShift (-1)
state_after: case h
R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
x✝ : R
⊢ ψ⁻¹ x✝ = (ψ.mulShift (-1)) x✝
tactic: ext
state_before: case h
R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
x✝ : R
⊢ ψ⁻¹ x✝ = (ψ.mulShift (-1)) x✝
state_after: no goals
tactic: rw [inv_apply, mulShift_apply, neg_mul, one_mul]
Theorem: AddLECancellable.le_add_tsub
File: Mathlib/Algebra/Order/Sub/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Preorder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
⊢ a ≤ a + b - b
state_after: α : Type u_1
β : Type u_2
inst✝³ : Preorder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
⊢ a ≤ b + a - b
tactic: rw [add_comm]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Preorder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
⊢ a ≤ b + a - b
state_after: no goals
tactic: exact hb.le_add_tsub_swap
Theorem: zsmul_neg'
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 : ℤ
⊢ a⁻¹ ^ n = a ^ (-n)
state_after: no goals
tactic: rw [inv_zpow, zpow_neg]
Theorem: HomologicalComplex₂.D₁_D₁
File: Mathlib/Algebra/Homology/TotalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁₂ i₁₂' i₁₂'' : I₁₂
⊢ K.D₁ c₁₂ i₁₂ i₁₂' ≫ K.D₁ c₁₂ i₁₂' i₁₂'' = 0
state_after: case pos
C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁₂ i₁₂' i₁₂'' : I₁₂
h₁ : c₁₂.Rel i₁₂ i₁₂'
⊢ K.D₁ c₁₂ i₁₂ i₁₂' ≫ K.D₁ c₁₂ i₁₂' i₁₂'' = 0

case neg
C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁₂ i₁₂' i₁₂'' : I₁₂
h₁ : ¬c₁₂.Rel i₁₂ i₁₂'
⊢ K.D₁ c₁₂ i₁₂ i₁₂' ≫ K.D₁ c₁₂ i₁₂' i₁₂'' = 0
tactic: by_cases h₁ : c₁₂.Rel i₁₂ i₁₂'
Theorem: Finset.image_some_eraseNone
File: Mathlib/Data/Finset/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq (Option α)
s : Finset (Option α)
⊢ image some (eraseNone s) = s.erase none
state_after: no goals
tactic: ext (_ | x) <;> simp
Theorem: HurwitzZeta.expZeta_zero
File: Mathlib/NumberTheory/LSeries/RiemannZeta.lean

Proof steps:
state_before: ⊢ expZeta 0 = riemannZeta
state_after: case h
s : ℂ
⊢ expZeta 0 s = riemannZeta s
tactic: ext1 s
state_before: case h
s : ℂ
⊢ expZeta 0 s = riemannZeta s
state_after: no goals
tactic: rw [expZeta, cosZeta_zero, add_right_eq_self, mul_eq_zero, eq_false_intro I_ne_zero, false_or,
    ← eq_neg_self_iff, ← sinZeta_neg, neg_zero]
Theorem: AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot_symm_mk_mk
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
I : Ideal R
f p : R[X]
⊢ (quotAdjoinRootEquivQuotPolynomialQuot I f).symm
      ((Ideal.Quotient.mk (span {Polynomial.map (Ideal.Quotient.mk I) f})) (Polynomial.map (Ideal.Quotient.mk I) p)) =
    (Ideal.Quotient.mk (Ideal.map (of f) I)) ((mk f) p)
state_after: no goals
tactic: rw [quotAdjoinRootEquivQuotPolynomialQuot, RingEquiv.symm_trans_apply,
    RingEquiv.symm_trans_apply, RingEquiv.symm_trans_apply, RingEquiv.symm_symm,
    Polynomial.quotQuotEquivComm_mk, Ideal.quotEquivOfEq_symm, Ideal.quotEquivOfEq_mk, ←
    RingHom.comp_apply, ← DoubleQuot.quotQuotMk,
    quotMapCMapSpanMkEquivQuotMapCQuotMapSpanMk_symm_quotQuotMk,
    quotMapOfEquivQuotMapCMapSpanMk_symm_mk]
Theorem: ProbabilityTheory.Kernel.const_zero
File: Mathlib/Probability/Kernel/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
⊢ const α 0 = 0
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
x : α
s : Set β
a✝ : MeasurableSet s
⊢ ((const α 0) x) s = (0 x) s
tactic: ext x s _
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
x : α
s : Set β
a✝ : MeasurableSet s
⊢ ((const α 0) x) s = (0 x) s
state_after: no goals
tactic: simp [const_apply]
Theorem: skewAdjoint.isStarNormal_of_mem
File: Mathlib/Algebra/Star/SelfAdjoint.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝¹ : Ring R
inst✝ : StarRing R
x : R
hx : x ∈ skewAdjoint R
⊢ Commute (star x) x
state_after: R : Type u_1
A : Type u_2
inst✝¹ : Ring R
inst✝ : StarRing R
x : R
hx : star x = -x
⊢ Commute (star x) x
tactic: simp only [mem_iff] at hx
state_before: R : Type u_1
A : Type u_2
inst✝¹ : Ring R
inst✝ : StarRing R
x : R
hx : star x = -x
⊢ Commute (star x) x
state_after: no goals
tactic: simp only [hx, Commute.neg_left, Commute.refl]
Theorem: Nat.bodd_succ
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n✝ n : ℕ
⊢ n.succ.bodd = !n.bodd
state_after: m n✝ n : ℕ
⊢ (match n.boddDiv2 with
      | (false, m) => (true, m)
      | (true, m) => (false, m.succ)).1 =
    !n.boddDiv2.1
tactic: simp only [bodd, boddDiv2]
state_before: m n✝ n : ℕ
⊢ (match n.boddDiv2 with
      | (false, m) => (true, m)
      | (true, m) => (false, m.succ)).1 =
    !n.boddDiv2.1
state_after: m✝ n✝ n : ℕ
b : Bool
m : ℕ
⊢ (match (b, m) with
      | (false, m) => (true, m)
      | (true, m) => (false, m.succ)).1 =
    !(b, m).1
tactic: let ⟨b,m⟩ := boddDiv2 n
state_before: m✝ n✝ n : ℕ
b : Bool
m : ℕ
⊢ (match (b, m) with
      | (false, m) => (true, m)
      | (true, m) => (false, m.succ)).1 =
    !(b, m).1
state_after: no goals
tactic: cases b <;> rfl
Theorem: RatFunc.ofFractionRing_add
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝ : CommRing K
p q : FractionRing K[X]
⊢ { toFractionRing := p + q } = { toFractionRing := p } + { toFractionRing := q }
state_after: no goals
tactic: simp only [HAdd.hAdd, Add.add, RatFunc.add]
Theorem: Set.Ici_iSup
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
inst✝ : CompleteLattice α
f : ι → α
x✝ : α
⊢ x✝ ∈ Ici (⨆ i, f i) ↔ x✝ ∈ ⋂ i, Ici (f i)
state_after: no goals
tactic: simp only [mem_Ici, iSup_le_iff, mem_iInter]
Theorem: Filter.mem_seq_iff
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f : Filter (α → β)
g : Filter α
s : Set β
⊢ s ∈ f.seq g ↔ ∃ u ∈ f, ∃ t ∈ g, u.seq t ⊆ s
state_after: no goals
tactic: simp only [mem_seq_def, seq_subset, exists_prop, iff_self_iff]
Theorem: Complex.I_mul_re
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
⊢ (I * z).re = -z.im
state_after: no goals
tactic: simp
Theorem: Multiset.sum_toList
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s✝ t : Multiset α
a : α
m : Multiset ι
f g : ι → α
s : Multiset α
⊢ s.toList.prod = s.prod
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s✝ t : Multiset α
a : α
m : Multiset ι
f g : ι → α
s : Multiset α
⊢ s.toList.prod = (↑s.toList).prod
tactic: conv_rhs => rw [← coe_toList s]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s✝ t : Multiset α
a : α
m : Multiset ι
f g : ι → α
s : Multiset α
⊢ s.toList.prod = (↑s.toList).prod
state_after: no goals
tactic: rw [prod_coe]
Theorem: Set.Icc_add_Icc_subset
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : Preorder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LE.le
a b c d : α
⊢ Icc a b * Icc c d ⊆ Icc (a * c) (b * d)
state_after: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : Preorder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LE.le
a b c d y : α
hya : a ≤ y
hyb : y ≤ b
z : α
hzc : c ≤ z
hzd : z ≤ d
⊢ (fun x x_1 => x * x_1) y z ∈ Icc (a * c) (b * d)
tactic: rintro x ⟨y, ⟨hya, hyb⟩, z, ⟨hzc, hzd⟩, rfl⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : Preorder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LE.le
a b c d y : α
hya : a ≤ y
hyb : y ≤ b
z : α
hzc : c ≤ z
hzd : z ≤ d
⊢ (fun x x_1 => x * x_1) y z ∈ Icc (a * c) (b * d)
state_after: no goals
tactic: exact ⟨mul_le_mul' hya hzc, mul_le_mul' hyb hzd⟩
Theorem: MeasureTheory.AEEqFun.liftRel_iff_coeFn
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
r : β → γ → Prop
f : α →ₘ[μ] β
g : α →ₘ[μ] γ
⊢ LiftRel r f g ↔ ∀ᵐ (a : α) ∂μ, r (↑f a) (↑g a)
state_after: no goals
tactic: rw [← liftRel_mk_mk, mk_coeFn, mk_coeFn]
Theorem: Submonoid.dense_induction
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
mem : ∀ x ∈ s, p x
one : p 1
mul : ∀ (x y : M), p x → p y → p (x * y)
⊢ p x
state_after: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
mem : ∀ x ∈ s, p x
one : p 1
mul : ∀ (x y : M), p x → p y → p (x * y)
this : ∀ x ∈ closure s, p x
⊢ p x
tactic: have : ∀ x ∈ closure s, p x := fun x hx => closure_induction hx mem one mul
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
mem : ∀ x ∈ s, p x
one : p 1
mul : ∀ (x y : M), p x → p y → p (x * y)
this : ∀ x ∈ closure s, p x
⊢ p x
state_after: no goals
tactic: simpa [hs] using this x
Theorem: Matrix.updateRow_apply
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
i' : m
⊢ M.updateRow i b i' j = if i' = i then b j else M i' j
state_after: case pos
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
i' : m
h : i' = i
⊢ M.updateRow i b i' j = if i' = i then b j else M i' j

case neg
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
i' : m
h : ¬i' = i
⊢ M.updateRow i b i' j = if i' = i then b j else M i' j
tactic: by_cases h : i' = i
Theorem: SimpleGraph.Walk.edges_map
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : G.Walk u v
⊢ (Walk.map f p).edges = List.map (Sym2.map ⇑f) p.edges
state_after: no goals
tactic: induction p with
  | nil => rfl
  | cons _ _ ih =>
    simp only [Walk.map_cons, edges_cons, List.map_cons, Sym2.map_pair_eq, List.cons.injEq,
      true_and, ih]
Theorem: Num.castNum_or
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
⊢ ∀ (m n : Num), ↑(m ||| n) = ↑m ||| ↑n
state_after: no goals
tactic: apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
   intros <;> (try cases_type* Bool) <;> rfl
Theorem: Int.odd_mul
File: Mathlib/Algebra/Ring/Int.lean

Proof steps:
state_before: m n : ℤ
⊢ Odd (m * n) ↔ Odd m ∧ Odd n
state_after: no goals
tactic: simp [not_or, parity_simps]
Theorem: succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a✝ p : α
hp : Prime p
a b : α
k l : ℕ
x✝² : p ^ k ∣ a
x✝¹ : p ^ l ∣ b
x✝ : p ^ (k + l + 1) ∣ a * b
x : α
hx : a = p ^ k * x
y : α
hy : b = p ^ l * y
z : α
hz : a * b = p ^ (k + l + 1) * z
⊢ p ^ (k + l) * (x * y) = p ^ (k + l) * (p * z)
state_after: no goals
tactic: simpa [mul_comm, pow_add, hx, hy, mul_assoc, mul_left_comm] using hz
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a✝ p : α
hp : Prime p
a b : α
k l : ℕ
x✝² : p ^ k ∣ a
x✝¹ : p ^ l ∣ b
x✝ : p ^ (k + l + 1) ∣ a * b
x : α
hx : a = p ^ k * x
y : α
hy : b = p ^ l * y
z : α
hz : a * b = p ^ (k + l + 1) * z
h : p ^ (k + l) * (x * y) = p ^ (k + l) * (p * z)
hp0 : p ^ (k + l) ≠ 0
⊢ x * y = p * z
state_after: no goals
tactic: rwa [mul_right_inj' hp0] at h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a✝ p : α
hp : Prime p
a b : α
k l : ℕ
x✝³ : p ^ k ∣ a
x✝² : p ^ l ∣ b
x✝¹ : p ^ (k + l + 1) ∣ a * b
x : α
hx : a = p ^ k * x
y : α
hy : b = p ^ l * y
z : α
hz : a * b = p ^ (k + l + 1) * z
h : p ^ (k + l) * (x * y) = p ^ (k + l) * (p * z)
hp0 : p ^ (k + l) ≠ 0
hpd : p ∣ x * y
x✝ : p ∣ x
d : α
hd : x = p * d
⊢ a = p ^ (k + 1) * d
state_after: no goals
tactic: simp [*, pow_succ, mul_comm, mul_left_comm, mul_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a✝ p : α
hp : Prime p
a b : α
k l : ℕ
x✝³ : p ^ k ∣ a
x✝² : p ^ l ∣ b
x✝¹ : p ^ (k + l + 1) ∣ a * b
x : α
hx : a = p ^ k * x
y : α
hy : b = p ^ l * y
z : α
hz : a * b = p ^ (k + l + 1) * z
h : p ^ (k + l) * (x * y) = p ^ (k + l) * (p * z)
hp0 : p ^ (k + l) ≠ 0
hpd : p ∣ x * y
x✝ : p ∣ y
d : α
hd : y = p * d
⊢ b = p ^ (l + 1) * d
state_after: no goals
tactic: simp [*, pow_succ, mul_comm, mul_left_comm, mul_assoc]
Theorem: Nat.binomial_eq_choose
File: Mathlib/Data/Nat/Choose/Multinomial.lean

Proof steps:
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a b : α
n : ℕ
inst✝ : DecidableEq α
h : a ≠ b
⊢ multinomial {a, b} f = (f a + f b).choose (f a)
state_after: no goals
tactic: simp [binomial_eq h, choose_eq_factorial_div_factorial (Nat.le_add_right _ _)]