ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Nat.multinomial_cons
File: Mathlib/Data/Nat/Choose/Multinomial.lean

Proof steps:
state_before: α : Type u_1
s : Finset α
f✝ : α → ℕ
a b : α
n : ℕ
ha : a ∉ s
f : α → ℕ
⊢ multinomial (cons a s ha) f = (f a + ∑ i ∈ s, f i).choose (f a) * multinomial s f
state_after: α : Type u_1
s : Finset α
f✝ : α → ℕ
a b : α
n : ℕ
ha : a ∉ s
f : α → ℕ
⊢ 0 < ∏ i ∈ cons a s ha, (f i)!
tactic: rw [multinomial, Nat.div_eq_iff_eq_mul_left _ (prod_factorial_dvd_factorial_sum _ _), prod_cons,
    multinomial, mul_assoc, mul_left_comm _ (f a)!,
    Nat.div_mul_cancel (prod_factorial_dvd_factorial_sum _ _), ← mul_assoc, Nat.choose_symm_add,
    Nat.add_choose_mul_factorial_mul_factorial, Finset.sum_cons]
state_before: α : Type u_1
s : Finset α
f✝ : α → ℕ
a b : α
n : ℕ
ha : a ∉ s
f : α → ℕ
⊢ 0 < ∏ i ∈ cons a s ha, (f i)!
state_after: no goals
tactic: positivity
Theorem: geom_sum_mul_neg
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α : Type u
inst✝ : Ring α
x : α
n : ℕ
⊢ (∑ i ∈ range n, x ^ i) * (1 - x) = 1 - x ^ n
state_after: α : Type u
inst✝ : Ring α
x : α
n : ℕ
this : -((∑ i ∈ range n, x ^ i) * (x - 1)) = -(x ^ n - 1)
⊢ (∑ i ∈ range n, x ^ i) * (1 - x) = 1 - x ^ n
tactic: have := congr_arg Neg.neg (geom_sum_mul x n)
state_before: α : Type u
inst✝ : Ring α
x : α
n : ℕ
this : -((∑ i ∈ range n, x ^ i) * (x - 1)) = -(x ^ n - 1)
⊢ (∑ i ∈ range n, x ^ i) * (1 - x) = 1 - x ^ n
state_after: α : Type u
inst✝ : Ring α
x : α
n : ℕ
this : (∑ i ∈ range n, x ^ i) * (1 - x) = 1 - x ^ n
⊢ (∑ i ∈ range n, x ^ i) * (1 - x) = 1 - x ^ n
tactic: rw [neg_sub, ← mul_neg, neg_sub] at this
state_before: α : Type u
inst✝ : Ring α
x : α
n : ℕ
this : (∑ i ∈ range n, x ^ i) * (1 - x) = 1 - x ^ n
⊢ (∑ i ∈ range n, x ^ i) * (1 - x) = 1 - x ^ n
state_after: no goals
tactic: exact this
Theorem: Submodule.map_unop_pow
File: Mathlib/Algebra/Algebra/Operations.lean

Proof steps:
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M✝ N P Q : Submodule R A
m n✝ : A
n : ℕ
M : Submodule R Aᵐᵒᵖ
⊢ map (↑(opLinearEquiv R).symm) (M ^ n) = map (↑(opLinearEquiv R).symm) M ^ n
state_after: no goals
tactic: rw [← comap_equiv_eq_map_symm, ← comap_equiv_eq_map_symm, comap_op_pow]
Theorem: Ideal.absNorm_span_insert
File: Mathlib/RingTheory/Ideal/Norm.lean

Proof steps:
state_before: S : Type u_1
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
r : S
s : Set S
⊢ absNorm (span {r}) ∣ ((Algebra.norm ℤ) r).natAbs
state_after: no goals
tactic: rw [absNorm_span_singleton]
Theorem: CategoryTheory.extendCofan_pt
File: Mathlib/CategoryTheory/Limits/Constructions/FiniteProductsOfBinaryProducts.lean

Proof steps:
state_before: J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
n : ℕ
f : Fin (n + 1) → C
c₁ : Cofan fun i => f i.succ
c₂ : BinaryCofan (f 0) c₁.pt
⊢ (b : Fin (n + 1)) → f b ⟶ c₂.pt
state_after: case refine_1
J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
n : ℕ
f : Fin (n + 1) → C
c₁ : Cofan fun i => f i.succ
c₂ : BinaryCofan (f 0) c₁.pt
⊢ f 0 ⟶ c₂.pt

case refine_2
J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
n : ℕ
f : Fin (n + 1) → C
c₁ : Cofan fun i => f i.succ
c₂ : BinaryCofan (f 0) c₁.pt
⊢ (i : Fin n) → f i.succ ⟶ c₂.pt
tactic: refine Fin.cases ?_ ?_
Theorem: HomologicalComplex.HomologySequence.composableArrows₃Functor_map
File: Mathlib/Algebra/Homology/HomologySequence.lean

Proof steps:
state_before: C : Type u_1
ι : Type u_2
inst✝² : Category.{?u.21319, u_1} C
inst✝¹ : Preadditive C
c : ComplexShape ι
K✝ : HomologicalComplex C c
i j : ι
hij : c.Rel i j
inst✝ : CategoryWithHomology C
K L : HomologicalComplex C c
φ : K ⟶ L
⊢ ((fun K => composableArrows₃ K i j) K).map' 0 1 ⋯ ⋯ ≫ opcyclesMap φ i =
    homologyMap φ i ≫ ((fun K => composableArrows₃ K i j) L).map' 0 1 ⋯ ⋯
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
ι : Type u_2
inst✝² : Category.{?u.21319, u_1} C
inst✝¹ : Preadditive C
c : ComplexShape ι
K✝ : HomologicalComplex C c
i j : ι
hij : c.Rel i j
inst✝ : CategoryWithHomology C
K L : HomologicalComplex C c
φ : K ⟶ L
⊢ ((fun K => composableArrows₃ K i j) K).map' 1 2 ⋯ ⋯ ≫ cyclesMap φ j =
    opcyclesMap φ i ≫ ((fun K => composableArrows₃ K i j) L).map' 1 2 ⋯ ⋯
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
ι : Type u_2
inst✝² : Category.{?u.21319, u_1} C
inst✝¹ : Preadditive C
c : ComplexShape ι
K✝ : HomologicalComplex C c
i j : ι
hij : c.Rel i j
inst✝ : CategoryWithHomology C
K L : HomologicalComplex C c
φ : K ⟶ L
⊢ ((fun K => composableArrows₃ K i j) K).map' 2 3 ⋯ ⋯ ≫ homologyMap φ j =
    cyclesMap φ j ≫ ((fun K => composableArrows₃ K i j) L).map' 2 3 ⋯ ⋯
state_after: no goals
tactic: aesop_cat
Theorem: Multiset.toFinset_card_eq_one_iff
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s✝ t u : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
s : Multiset α
⊢ s.toFinset.card = 1 ↔ Multiset.card s ≠ 0 ∧ ∃ a, s = Multiset.card s • {a}
state_after: no goals
tactic: simp_rw [card_eq_one, Multiset.toFinset_eq_singleton_iff, exists_and_left]
Theorem: CategoryTheory.CosimplicialObject.instCategoryAugmented_id_right_app
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
⊢ Category.{?u.173955, max u v} (Augmented C)
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
⊢ Category.{?u.173955, max u v} (Comma (const C) (𝟭 (CosimplicialObject C)))
tactic: dsimp only [Augmented]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
⊢ Category.{?u.173955, max u v} (Comma (const C) (𝟭 (CosimplicialObject C)))
state_after: no goals
tactic: infer_instance
Theorem: RatFunc.laurent_C
File: Mathlib/FieldTheory/Laurent.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
x : R
⊢ (laurent r) (C x) = C x
state_after: no goals
tactic: rw [← algebraMap_C, laurent_algebraMap, taylor_C]
Theorem: IsClosed.inter
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsClosed s₁
h₂ : IsClosed s₂
⊢ IsClosed (s₁ ∩ s₂)
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsOpen s₁ᶜ
h₂ : IsOpen s₂ᶜ
⊢ IsOpen (s₁ ∩ s₂)ᶜ
tactic: rw [← isOpen_compl_iff] at *
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsOpen s₁ᶜ
h₂ : IsOpen s₂ᶜ
⊢ IsOpen (s₁ ∩ s₂)ᶜ
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsOpen s₁ᶜ
h₂ : IsOpen s₂ᶜ
⊢ IsOpen (s₁ᶜ ∪ s₂ᶜ)
tactic: rw [compl_inter]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsOpen s₁ᶜ
h₂ : IsOpen s₂ᶜ
⊢ IsOpen (s₁ᶜ ∪ s₂ᶜ)
state_after: no goals
tactic: exact IsOpen.union h₁ h₂
Theorem: Even.isSquare_pow
File: Mathlib/Algebra/Group/Even.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : Monoid α
n : ℕ
a : α
⊢ Even n → ∀ (a : α), IsSquare (a ^ n)
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : Monoid α
a✝ : α
n : ℕ
a : α
⊢ IsSquare (a ^ (n + n))
tactic: rintro ⟨n, rfl⟩ a
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : Monoid α
a✝ : α
n : ℕ
a : α
⊢ IsSquare (a ^ (n + n))
state_after: no goals
tactic: exact ⟨a ^ n, pow_add _ _ _⟩
Theorem: CategoryTheory.ComposableArrows.mkOfObjOfMapSucc_arrow
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
obj : Fin (n + 1) → C
mapSucc : (i : Fin n) → obj i.castSucc ⟶ obj i.succ
i : ℕ
hi : autoParam (i < n) _auto✝
⊢ ((mkOfObjOfMapSucc obj mapSucc).arrow i hi).hom = eqToHom ⋯ ≫ (mk₁ (mapSucc ⟨i, hi⟩)).hom ≫ eqToHom ⋯
state_after: no goals
tactic: simpa using mkOfObjOfMapSucc_map_succ obj mapSucc i hi
Theorem: Finsupp.single_apply_eq_zero
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
a✝ a' : α
b✝ : M
a x : α
b : M
⊢ (single a b) x = 0 ↔ x = a → b = 0
state_after: no goals
tactic: simp [single_eq_set_indicator]
Theorem: ProbabilityTheory.centralMoment_zero
File: Mathlib/Probability/Moments.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
hp : p ≠ 0
⊢ centralMoment 0 p μ = 0
state_after: no goals
tactic: simp only [centralMoment, hp, Pi.zero_apply, integral_const, smul_eq_mul,
    mul_zero, zero_sub, Pi.pow_apply, Pi.neg_apply, neg_zero, zero_pow, Ne, not_false_iff]
Theorem: Real.strictMono_eulerMascheroniSeq
File: Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean

Proof steps:
state_before: ⊢ StrictMono eulerMascheroniSeq
state_after: n : ℕ
⊢ eulerMascheroniSeq n < eulerMascheroniSeq (n + 1)
tactic: refine strictMono_nat_of_lt_succ (fun n ↦ ?_)
state_before: n : ℕ
⊢ eulerMascheroniSeq n < eulerMascheroniSeq (n + 1)
state_after: n : ℕ
⊢ log (1 + (↑n + 1)⁻¹) < (↑n + 1)⁻¹
tactic: rw [eulerMascheroniSeq, eulerMascheroniSeq, ← sub_pos, sub_sub_sub_comm,
    harmonic_succ, add_comm, Rat.cast_add, add_sub_cancel_right,
    ← log_div (by positivity) (by positivity), add_div, Nat.cast_add_one,
    Nat.cast_add_one, div_self (by positivity), sub_pos, one_div, Rat.cast_inv, Rat.cast_add,
    Rat.cast_one, Rat.cast_natCast]
state_before: n : ℕ
⊢ log (1 + (↑n + 1)⁻¹) < (↑n + 1)⁻¹
state_after: case refine_1
n : ℕ
⊢ 0 < 1 + (↑n + 1)⁻¹

case refine_2
n : ℕ
⊢ 0 < (↑n + 1)⁻¹

case refine_3
n : ℕ
⊢ 1 + (↑n + 1)⁻¹ - 1 = (↑n + 1)⁻¹
tactic: refine (log_lt_sub_one_of_pos ?_ (ne_of_gt <| lt_add_of_pos_right _ ?_)).trans_le (le_of_eq ?_)
Theorem: QuotientAddGroup.norm_eq_infDist
File: Mathlib/Analysis/Normed/Group/Quotient.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
⊢ ‖x‖ = infDist 0 {m | ↑m = x}
state_after: no goals
tactic: simp only [AddSubgroup.quotient_norm_eq, infDist_eq_iInf, sInf_image', dist_zero_left]
Theorem: ArithmeticFunction.prod_eq_iff_prod_pow_moebius_eq_of_nonzero
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommGroupWithZero R
f g : ℕ → R
hf : ∀ (n : ℕ), 0 < n → f n ≠ 0
hg : ∀ (n : ℕ), 0 < n → g n ≠ 0
⊢ (∀ n > 0, ∏ i ∈ n.divisors, f i = g n) ↔ ∀ n > 0, ∏ x ∈ n.divisorsAntidiagonal, g x.2 ^ μ x.1 = f n
state_after: case refine_1
R : Type u_1
inst✝ : CommGroupWithZero R
f g : ℕ → R
hf : ∀ (n : ℕ), 0 < n → f n ≠ 0
hg : ∀ (n : ℕ), 0 < n → g n ≠ 0
n : ℕ
hn : n > 0
⊢ ∏ i ∈ n.divisors, f i = g n ↔
    (∏ i ∈ n.divisors, if h : 0 < i then Units.mk0 (f i) ⋯ else 1) = if h : 0 < n then Units.mk0 (g n) ⋯ else 1

case refine_2
R : Type u_1
inst✝ : CommGroupWithZero R
f g : ℕ → R
hf : ∀ (n : ℕ), 0 < n → f n ≠ 0
hg : ∀ (n : ℕ), 0 < n → g n ≠ 0
n : ℕ
hn : n > 0
⊢ (∏ x ∈ n.divisorsAntidiagonal, (if h : 0 < x.2 then Units.mk0 (g x.2) ⋯ else 1) ^ μ x.1 =
      if h : 0 < n then Units.mk0 (f n) ⋯ else 1) ↔
    ∏ x ∈ n.divisorsAntidiagonal, g x.2 ^ μ x.1 = f n
tactic: refine
      Iff.trans
        (Iff.trans (forall_congr' fun n => ?_)
          (@prod_eq_iff_prod_pow_moebius_eq Rˣ _
            (fun n => if h : 0 < n then Units.mk0 (f n) (hf n h) else 1) fun n =>
            if h : 0 < n then Units.mk0 (g n) (hg n h) else 1))
        (forall_congr' fun n => ?_) <;>
    refine imp_congr_right fun hn => ?_
Theorem: bertrand_main_inequality
File: Mathlib/NumberTheory/Bertrand.lean

Proof steps:
state_before: n : ℕ
n_large : 512 ≤ n
⊢ n * (2 * n) ^ (2 * n).sqrt * 4 ^ (2 * n / 3) ≤ 4 ^ n
state_after: n : ℕ
n_large : 512 ≤ n
⊢ ↑(n * (2 * n) ^ (2 * n).sqrt * 4 ^ (2 * n / 3)) ≤ ↑(4 ^ n)
tactic: rw [← @cast_le ℝ]
state_before: n : ℕ
n_large : 512 ≤ n
⊢ ↑(n * (2 * n) ^ (2 * n).sqrt * 4 ^ (2 * n / 3)) ≤ ↑(4 ^ n)
state_after: n : ℕ
n_large : 512 ≤ n
⊢ ↑n * (↑2 * ↑n) ^ ↑(2 * n).sqrt * ↑4 ^ ↑(2 * n / 3) ≤ ↑4 ^ ↑n
tactic: simp only [cast_add, cast_one, cast_mul, cast_pow, ← Real.rpow_natCast]
state_before: n : ℕ
n_large : 512 ≤ n
⊢ ↑n * (↑2 * ↑n) ^ ↑(2 * n).sqrt * ↑4 ^ ↑(2 * n / 3) ≤ ↑4 ^ ↑n
state_after: n : ℕ
n_large : 512 ≤ n
⊢ ↑n * (↑2 * ↑n) ^ ↑(2 * n).sqrt * ↑4 ^ ↑(2 * n / 3) ≤ ↑n * (2 * ↑n) ^ √(2 * ↑n) * 4 ^ (2 * ↑n / 3)
tactic: refine _root_.trans ?_ (Bertrand.real_main_inequality (by exact_mod_cast n_large))
state_before: n : ℕ
n_large : 512 ≤ n
⊢ ↑n * (↑2 * ↑n) ^ ↑(2 * n).sqrt * ↑4 ^ ↑(2 * n / 3) ≤ ↑n * (2 * ↑n) ^ √(2 * ↑n) * 4 ^ (2 * ↑n / 3)
state_after: case h₁.h.hx
n : ℕ
n_large : 512 ≤ n
⊢ 1 ≤ ↑2 * ↑n

case h₁.h.hyz
n : ℕ
n_large : 512 ≤ n
⊢ ↑(2 * n).sqrt ≤ √(2 * ↑n)

case h₂.hx
n : ℕ
n_large : 512 ≤ n
⊢ 1 ≤ ↑4

case h₂.hyz
n : ℕ
n_large : 512 ≤ n
⊢ ↑(2 * n / 3) ≤ 2 * ↑n / 3
tactic: gcongr
Theorem: Nat.two_pow_succ
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
⊢ 2 ^ (n + 1) = 2 ^ n + 2 ^ n
state_after: no goals
tactic: simp [Nat.pow_succ, Nat.mul_two]
Theorem: sup_div_inf_eq_mabs_div
File: Mathlib/Algebra/Order/Group/Unbundled/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ (a ⊔ b) / (a ⊓ b) = mabs (b / a)
state_after: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ a / b ⊔ b / a ⊔ 1 = mabs (b / a)
tactic: simp_rw [sup_div, div_inf, div_self', sup_comm, sup_sup_sup_comm, sup_idem]
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ a / b ⊔ b / a ⊔ 1 = mabs (b / a)
state_after: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ 1 ≤ mabs (b / a)
tactic: rw [← inv_div, sup_comm (b := _ / _), ← mabs, sup_eq_left]
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ 1 ≤ mabs (b / a)
state_after: no goals
tactic: exact one_le_mabs _
Theorem: AdicCompletion.isAdicCauchy_iff
File: Mathlib/RingTheory/AdicCompletion/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : ℕ → M
⊢ IsAdicCauchy I M f ↔ ∀ (n : ℕ), f n ≡ f (n + 1) [SMOD I ^ n • ⊤]
state_after: case mp
R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : ℕ → M
⊢ IsAdicCauchy I M f → ∀ (n : ℕ), f n ≡ f (n + 1) [SMOD I ^ n • ⊤]

case mpr
R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : ℕ → M
⊢ (∀ (n : ℕ), f n ≡ f (n + 1) [SMOD I ^ n • ⊤]) → IsAdicCauchy I M f
tactic: constructor
Theorem: IsAddSubgroup.trivial_eq_closure
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
⊢ trivial G ⊆ Group.closure ∅
state_after: no goals
tactic: simp [Set.subset_def, (Group.closure.isSubgroup _).one_mem]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
⊢ ∅ ⊆ trivial G
state_after: no goals
tactic: simp
Theorem: dense_iff_inter_open
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ Dense s ↔ ∀ (U : Set X), IsOpen U → U.Nonempty → (U ∩ s).Nonempty
state_after: case mp
X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : Dense s
⊢ ∀ (U : Set X), IsOpen U → U.Nonempty → (U ∩ s).Nonempty

case mpr
X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : ∀ (U : Set X), IsOpen U → U.Nonempty → (U ∩ s).Nonempty
⊢ Dense s
tactic: constructor <;> intro h
Theorem: Stream'.tail_even
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ s.even.tail = s.tail.tail.even
state_after: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ (corec (fun s => s.head) (fun s => s.tail.tail) s).tail = corec (fun s => s.head) (fun s => s.tail.tail) s.tail.tail
tactic: unfold even
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ (corec (fun s => s.head) (fun s => s.tail.tail) s).tail = corec (fun s => s.head) (fun s => s.tail.tail) s.tail.tail
state_after: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ (s.head :: corec (fun s => s.head) (fun s => s.tail.tail) s.tail.tail).tail =
    corec (fun s => s.head) (fun s => s.tail.tail) s.tail.tail
tactic: rw [corec_eq]
state_before: α : Type u
β : Type v
δ : Type w
s : Stream' α
⊢ (s.head :: corec (fun s => s.head) (fun s => s.tail.tail) s.tail.tail).tail =
    corec (fun s => s.head) (fun s => s.tail.tail) s.tail.tail
state_after: no goals
tactic: rfl
Theorem: Multiset.nsmul_count
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 : ι → α
inst✝ : DecidableEq α
a : α
⊢ a ^ count a s = (filter (Eq a) s).prod
state_after: no goals
tactic: rw [filter_eq, prod_replicate]
Theorem: CategoryTheory.OverPresheafAux.unitAuxAux_inv_app_fst
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
A F : Cᵒᵖ ⥤ Type v
η : F ⟶ A
⊢ ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y),
    (yonedaCollectionPresheaf A (restrictedYonedaObj η)).map f ≫ ((fun X => unitAuxAuxAux η (unop X)) Y).hom =
      ((fun X => unitAuxAuxAux η (unop X)) X).hom ≫ F.map f
state_after: no goals
tactic: aesop_cat
Theorem: AntilipschitzWith.id
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
⊢ edist x y ≤ ↑1 * edist (id x) (id y)
state_after: no goals
tactic: simp only [ENNReal.coe_one, one_mul, id, le_refl]
Theorem: CategoryTheory.IsPushout.of_hasBinaryCoproduct
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝² : HasBinaryCoproduct X Y
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
⊢ IsPushout 0 0 coprod.inl coprod.inr
state_after: no goals
tactic: convert @of_is_coproduct _ _ 0 X Y _ (colimit.isColimit _) HasZeroObject.zeroIsInitial
    <;> subsingleton
Theorem: Turing.TM2to1.supports_run
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
inst✝¹ : Inhabited Λ
σ : Type u_4
inst✝ : Inhabited σ
S : Finset Λ
k : K
s : StAct k
q : Stmt₂
⊢ TM2.SupportsStmt S (stRun s q) ↔ TM2.SupportsStmt S q
state_after: no goals
tactic: cases s <;> rfl
Theorem: AddSubmonoid.add_leftNegEquiv_symm
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

Proof steps:
state_before: M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : ↥S
⊢ ↑x * ↑((S.leftInvEquiv hS).symm x) = 1
state_after: case h.e'_2.h.e'_5.h.e'_3
M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : ↥S
⊢ x = (S.leftInvEquiv hS) ((S.leftInvEquiv hS).symm x)
tactic: convert S.leftInvEquiv_mul hS ((S.leftInvEquiv hS).symm x)
state_before: case h.e'_2.h.e'_5.h.e'_3
M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : ↥S
⊢ x = (S.leftInvEquiv hS) ((S.leftInvEquiv hS).symm x)
state_after: no goals
tactic: simp
Theorem: Filter.lift_top
File: Mathlib/Order/Filter/Lift.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f f₁ f₂ : Filter α
g✝ g₁ g₂ g : Set α → Filter β
⊢ ⊤.lift g = g univ
state_after: no goals
tactic: simp [Filter.lift]
Theorem: Matrix.PosSemidef.toLinearMap₂'_zero_iff
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosSemidef
x : n → 𝕜
⊢ (((toLinearMap₂' 𝕜) A) (star x)) x = 0 ↔ (toLin' A) x = 0
state_after: no goals
tactic: simpa only [toLinearMap₂'_apply', toLin'_apply] using hA.dotProduct_mulVec_zero_iff x
Theorem: Set.star_subset
File: Mathlib/Algebra/Star/Pointwise.lean

Proof steps:
state_before: α : Type u_1
s✝ t✝ : Set α
a : α
inst✝ : InvolutiveStar α
s t : Set α
⊢ s⋆ ⊆ t ↔ s ⊆ t⋆
state_after: no goals
tactic: rw [← star_subset_star, star_star]