ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: NumberField.InfinitePlace.card_filter_mk_eq
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
w : InfinitePlace K
⊢ (Finset.filter (fun φ => mk φ = w) Finset.univ).card = w.mult
state_after: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
w : InfinitePlace K
⊢ (Finset.filter (fun x => x = w.embedding ∨ x = star w.embedding) Finset.univ).card = w.mult
tactic: conv_lhs =>
    congr; congr; ext
    rw [← mk_embedding w, mk_eq_iff, ComplexEmbedding.conjugate, star_involutive.eq_iff]
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
w : InfinitePlace K
⊢ (Finset.filter (fun x => x = w.embedding ∨ x = star w.embedding) Finset.univ).card = w.mult
state_after: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
w : InfinitePlace K
⊢ ({w.embedding} ∪ {ComplexEmbedding.conjugate w.embedding}).card = if w.IsReal then 1 else 2
tactic: simp_rw [Finset.filter_or, Finset.filter_eq' _ (embedding w),
    Finset.filter_eq' _ (ComplexEmbedding.conjugate (embedding w)),
    Finset.mem_univ, ite_true, mult]
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
w : InfinitePlace K
⊢ ({w.embedding} ∪ {ComplexEmbedding.conjugate w.embedding}).card = if w.IsReal then 1 else 2
state_after: case pos
k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
w : InfinitePlace K
hw : w.IsReal
⊢ ({w.embedding} ∪ {ComplexEmbedding.conjugate w.embedding}).card = 1

case neg
k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
w : InfinitePlace K
hw : ¬w.IsReal
⊢ ({w.embedding} ∪ {ComplexEmbedding.conjugate w.embedding}).card = 2
tactic: split_ifs with hw
Theorem: Ring.smeval_ascPochhammer_neg_of_lt
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n k : ℕ
h : n < k
⊢ (ascPochhammer ℕ k).smeval (-↑n) = 0
state_after: no goals
tactic: rw [show k = n + (k - n - 1) + 1 by omega, smeval_ascPochhammer_neg_add]
Theorem: Unitization.algHom_ext''
File: Mathlib/Algebra/Algebra/Unitization.lean

Proof steps:
state_before: S : Type u_1
R : Type u_2
A : Type u_3
inst✝¹⁴ : CommSemiring S
inst✝¹³ : CommSemiring R
inst✝¹² : NonUnitalSemiring A
inst✝¹¹ : Module R A
inst✝¹⁰ : SMulCommClass R A A
inst✝⁹ : IsScalarTower R A A
B : Type u_4
inst✝⁸ : Semiring B
inst✝⁷ : Algebra S B
inst✝⁶ : Algebra S R
inst✝⁵ : DistribMulAction S A
inst✝⁴ : IsScalarTower S R A
C : Type u_5
inst✝³ : Semiring C
inst✝² : Algebra R C
F : Type u_6
inst✝¹ : FunLike F (Unitization R A) C
inst✝ : AlgHomClass F R (Unitization R A) C
φ ψ : F
h : ∀ (a : A), φ ↑a = ψ ↑a
r : R
⊢ φ ((algebraMap R (Unitization R A)) r) = ψ ((algebraMap R (Unitization R A)) r)
state_after: no goals
tactic: simp only [AlgHomClass.commutes]
Theorem: abs_sup_sub_sup_le_abs
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 c : α
⊢ mabs ((a ⊔ c) / (b ⊔ c)) ≤ mabs (a / b)
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 c : α
⊢ mabs ((a ⊔ c) / (b ⊔ c)) * mabs ?m.25410 ≤ mabs (a / b)
tactic: apply le_of_mul_le_of_one_le_left _ (one_le_mabs _)
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 c : α
⊢ mabs ((a ⊔ c) / (b ⊔ c)) * mabs ?m.25410 ≤ mabs (a / b)
state_after: no goals
tactic: rw [mabs_div_sup_mul_mabs_div_inf]
Theorem: intervalIntegral.integral_mul_const
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜✝ : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b : ℝ
f✝ g : ℝ → E
μ : Measure ℝ
𝕜 : Type u_6
inst✝ : RCLike 𝕜
r : 𝕜
f : ℝ → 𝕜
⊢ ∫ (x : ℝ) in a..b, f x * r ∂μ = (∫ (x : ℝ) in a..b, f x ∂μ) * r
state_after: no goals
tactic: simpa only [mul_comm r] using integral_const_mul r f
Theorem: Ordinal.eq_zero_or_opow_omega_le_of_mul_eq_right
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: a b : Ordinal.{u}
hab : a * b = b
⊢ b = 0 ∨ a ^ ω ≤ b
state_after: case inl
a b : Ordinal.{u}
hab : a * b = b
ha : a = 0
⊢ b = 0 ∨ a ^ ω ≤ b

case inr
a b : Ordinal.{u}
hab : a * b = b
ha : 0 < a
⊢ b = 0 ∨ a ^ ω ≤ b
tactic: rcases eq_zero_or_pos a with ha | ha
state_before: case inr
a b : Ordinal.{u}
hab : a * b = b
ha : 0 < a
⊢ b = 0 ∨ a ^ ω ≤ b
state_after: case inr
a b : Ordinal.{u}
hab : a * b = b
ha : 0 < a
⊢ ¬b = 0 → a ^ ω ≤ b
tactic: rw [or_iff_not_imp_left]
state_before: case inr
a b : Ordinal.{u}
hab : a * b = b
ha : 0 < a
⊢ ¬b = 0 → a ^ ω ≤ b
state_after: case inr
a b : Ordinal.{u}
hab : a * b = b
ha : 0 < a
hb : ¬b = 0
⊢ a ^ ω ≤ b
tactic: intro hb
state_before: case inr
a b : Ordinal.{u}
hab : a * b = b
ha : 0 < a
hb : ¬b = 0
⊢ a ^ ω ≤ b
state_after: case inr
a b : Ordinal.{u}
hab : a * b = b
ha : 0 < a
hb : ¬b = 0
⊢ nfp (fun x => a * x) 1 ≤ b
tactic: rw [← nfp_mul_one ha]
state_before: case inr
a b : Ordinal.{u}
hab : a * b = b
ha : 0 < a
hb : ¬b = 0
⊢ nfp (fun x => a * x) 1 ≤ b
state_after: case inr
a b : Ordinal.{u}
hab : a * b = b
ha : 0 < a
hb : 1 ≤ b
⊢ nfp (fun x => a * x) 1 ≤ b
tactic: rw [← Ne, ← one_le_iff_ne_zero] at hb
state_before: case inr
a b : Ordinal.{u}
hab : a * b = b
ha : 0 < a
hb : 1 ≤ b
⊢ nfp (fun x => a * x) 1 ≤ b
state_after: no goals
tactic: exact nfp_le_fp (mul_isNormal ha).monotone hb (le_of_eq hab)
Theorem: Ordinal.CNF_fst_le_log
File: Mathlib/SetTheory/Ordinal/CantorNormalForm.lean

Proof steps:
state_before: b o : Ordinal.{u}
x : Ordinal.{u} × Ordinal.{u}
⊢ x ∈ CNF b o → x.1 ≤ log b o
state_after: case refine_1
b o : Ordinal.{u}
x : Ordinal.{u} × Ordinal.{u}
⊢ x ∈ CNF b 0 → x.1 ≤ log b 0

case refine_2
b o✝ : Ordinal.{u}
x : Ordinal.{u} × Ordinal.{u}
o : Ordinal.{u}
ho : o ≠ 0
H : x ∈ CNF b (o % b ^ log b o) → x.1 ≤ log b (o % b ^ log b o)
⊢ x ∈ CNF b o → x.1 ≤ log b o
tactic: refine CNFRec b ?_ (fun o ho H ↦ ?_) o
Theorem: List.drop_set_of_lt
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a : α
n m : Nat
l : List α
h : n < m
i : Nat
⊢ (drop m (l.set n a))[i]? = (drop m l)[i]?
state_after: no goals
tactic: rw [getElem?_drop, getElem?_drop, getElem?_set_ne (by omega)]
Theorem: MeasureTheory.Measure.addHaar_ball_mul_of_pos
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

Proof steps:
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 < r
s : ℝ
⊢ μ (ball x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (ball 0 s)
state_after: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 < r
s : ℝ
this : ball 0 (r * s) = r • ball 0 s
⊢ μ (ball x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (ball 0 s)
tactic: have : ball (0 : E) (r * s) = r • ball (0 : E) s := by
    simp only [_root_.smul_ball hr.ne' (0 : E) s, Real.norm_eq_abs, abs_of_nonneg hr.le, smul_zero]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 < r
s : ℝ
this : ball 0 (r * s) = r • ball 0 s
⊢ μ (ball x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (ball 0 s)
state_after: no goals
tactic: simp only [this, addHaar_smul, abs_of_nonneg hr.le, addHaar_ball_center, abs_pow]
Theorem: Path.map_id
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
⊢ γ.map ⋯ = γ
state_after: case a.h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
x✝ : ↑I
⊢ (γ.map ⋯) x✝ = γ x✝
tactic: ext
state_before: case a.h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
x✝ : ↑I
⊢ (γ.map ⋯) x✝ = γ x✝
state_after: no goals
tactic: rfl
Theorem: WeierstrassCurve.natDegree_preΨ'_pos
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
hn : 2 < n
h : ↑n ≠ 0
⊢ 0 < (W.preΨ' n).natDegree
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
hn : 2 < n
h : ↑n ≠ 0
⊢ 2 ≤ n ^ 2 - if Even n then 4 else 1
tactic: rw [W.natDegree_preΨ' h, Nat.div_pos_iff two_ne_zero]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℕ
hn : 2 < n
h : ↑n ≠ 0
⊢ 2 ≤ n ^ 2 - if Even n then 4 else 1
state_after: no goals
tactic: split_ifs <;>
    exact Nat.AtLeastTwo.prop.trans <| Nat.sub_le_sub_right (Nat.pow_le_pow_of_le_left hn 2) _
Theorem: Monoid.PushoutI.NormalWord.prod_summand_smul
File: Mathlib/GroupTheory/PushoutI.lean

Proof steps:
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
i : ι
g : G i
w : NormalWord d
⊢ (g • w).prod = (of i) g * w.prod
state_after: no goals
tactic: simp only [prod, summand_smul_def', equivPair, rcons, Word.equivPair_symm,
    Equiv.coe_fn_mk, Equiv.coe_fn_symm_mk, Word.equivPair_smul_same,
    Word.equivPair_tail_eq_inv_smul, Word.rcons_eq_smul, ← of_apply_eq_base φ i,
    MonoidHom.apply_ofInjective_symm, equiv_fst_eq_mul_inv, mul_assoc, map_mul, map_inv,
    Word.prod_smul, ofCoprodI_of, inv_mul_cancel_left, mul_inv_cancel_left]
Theorem: AddAction.nsmul_vadd_eq_iff_minimalPeriod_dvd
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
a : G
b : α
n : ℕ
⊢ a ^ n • b = b ↔ minimalPeriod (fun x => a • x) b ∣ n
state_after: no goals
tactic: rw [← period_eq_minimalPeriod, pow_smul_eq_iff_period_dvd]
Theorem: CategoryTheory.PresheafHom.isAmalgamation_iff
File: Mathlib/CategoryTheory/Sites/SheafHom.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝ : Category.{v', u'} A
F G : Cᵒᵖ ⥤ A
X : C
S : Sieve X
x : Presieve.FamilyOfElements (presheafHom F G) S.arrows
hx : x.Compatible
y : (presheafHom F G).obj (op X)
⊢ x.IsAmalgamation y ↔
    ∀ (Y : C) (g : Y ⟶ X) (hg : S.arrows g), y.app (op (Over.mk g)) = (x g hg).app (op (Over.mk (𝟙 Y)))
state_after: case mp
C : Type u
inst✝¹ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝ : Category.{v', u'} A
F G : Cᵒᵖ ⥤ A
X : C
S : Sieve X
x : Presieve.FamilyOfElements (presheafHom F G) S.arrows
hx : x.Compatible
y : (presheafHom F G).obj (op X)
⊢ x.IsAmalgamation y →
    ∀ (Y : C) (g : Y ⟶ X) (hg : S.arrows g), y.app (op (Over.mk g)) = (x g hg).app (op (Over.mk (𝟙 Y)))

case mpr
C : Type u
inst✝¹ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝ : Category.{v', u'} A
F G : Cᵒᵖ ⥤ A
X : C
S : Sieve X
x : Presieve.FamilyOfElements (presheafHom F G) S.arrows
hx : x.Compatible
y : (presheafHom F G).obj (op X)
⊢ (∀ (Y : C) (g : Y ⟶ X) (hg : S.arrows g), y.app (op (Over.mk g)) = (x g hg).app (op (Over.mk (𝟙 Y)))) →
    x.IsAmalgamation y
tactic: constructor
Theorem: Multiset.add_union_distrib
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a b : α
s t u : Multiset α
⊢ s + (t ∪ u) = s + t ∪ (s + u)
state_after: no goals
tactic: rw [add_comm, union_add_distrib, add_comm s, add_comm s]
Theorem: AlgEquiv.restrictNormal_trans
File: Mathlib/FieldTheory/Normal.lean

Proof steps:
state_before: F : Type u_1
K : Type u_2
inst✝¹⁸ : Field F
inst✝¹⁷ : Field K
inst✝¹⁶ : Algebra F K
K₁ : Type u_3
K₂ : Type u_4
K₃ : Type u_5
inst✝¹⁵ : Field F
inst✝¹⁴ : Field K₁
inst✝¹³ : Field K₂
inst✝¹² : Field K₃
inst✝¹¹ : Algebra F K₁
inst✝¹⁰ : Algebra F K₂
inst✝⁹ : Algebra F K₃
ϕ : K₁ →ₐ[F] K₂
χ : K₁ ≃ₐ[F] K₂
ψ : K₂ →ₐ[F] K₃
ω : K₂ ≃ₐ[F] K₃
E : Type u_6
inst✝⁸ : Field E
inst✝⁷ : Algebra F E
inst✝⁶ : Algebra E K₁
inst✝⁵ : Algebra E K₂
inst✝⁴ : Algebra E K₃
inst✝³ : IsScalarTower F E K₁
inst✝² : IsScalarTower F E K₂
inst✝¹ : IsScalarTower F E K₃
inst✝ : Normal F E
x✝ : E
⊢ (algebraMap E K₃) (((χ.trans ω).restrictNormal E) x✝) =
    (algebraMap E K₃) (((χ.restrictNormal E).trans (ω.restrictNormal E)) x✝)
state_after: no goals
tactic: simp only [AlgEquiv.trans_apply, AlgEquiv.restrictNormal_commutes]
Theorem: Multiset.cons_product
File: Mathlib/Data/Multiset/Bind.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
b : β
s : Multiset α
t : Multiset β
⊢ (a ::ₘ s) ×ˢ t = map (Prod.mk a) t + s ×ˢ t
state_after: no goals
tactic: simp [SProd.sprod, product]
Theorem: LinearEquiv.toModuleIso_inv
File: Mathlib/Algebra/Category/ModuleCat/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
X₁ X₂ : Type v
g₁ : AddCommGroup X₁
g₂ : AddCommGroup X₂
m₁ : Module R X₁
m₂ : Module R X₂
e : X₁ ≃ₗ[R] X₂
⊢ ↑e ≫ ↑e.symm = 𝟙 (ModuleCat.of R X₁)
state_after: case h
R : Type u
inst✝ : Ring R
X₁ X₂ : Type v
g₁ : AddCommGroup X₁
g₂ : AddCommGroup X₂
m₁ : Module R X₁
m₂ : Module R X₂
e : X₁ ≃ₗ[R] X₂
x✝ : ↑(ModuleCat.of R X₁)
⊢ (↑e ≫ ↑e.symm) x✝ = (𝟙 (ModuleCat.of R X₁)) x✝
tactic: ext
state_before: case h
R : Type u
inst✝ : Ring R
X₁ X₂ : Type v
g₁ : AddCommGroup X₁
g₂ : AddCommGroup X₂
m₁ : Module R X₁
m₂ : Module R X₂
e : X₁ ≃ₗ[R] X₂
x✝ : ↑(ModuleCat.of R X₁)
⊢ (↑e ≫ ↑e.symm) x✝ = (𝟙 (ModuleCat.of R X₁)) x✝
state_after: no goals
tactic: apply e.left_inv
state_before: R : Type u
inst✝ : Ring R
X₁ X₂ : Type v
g₁ : AddCommGroup X₁
g₂ : AddCommGroup X₂
m₁ : Module R X₁
m₂ : Module R X₂
e : X₁ ≃ₗ[R] X₂
⊢ ↑e.symm ≫ ↑e = 𝟙 (ModuleCat.of R X₂)
state_after: case h
R : Type u
inst✝ : Ring R
X₁ X₂ : Type v
g₁ : AddCommGroup X₁
g₂ : AddCommGroup X₂
m₁ : Module R X₁
m₂ : Module R X₂
e : X₁ ≃ₗ[R] X₂
x✝ : ↑(ModuleCat.of R X₂)
⊢ (↑e.symm ≫ ↑e) x✝ = (𝟙 (ModuleCat.of R X₂)) x✝
tactic: ext
state_before: case h
R : Type u
inst✝ : Ring R
X₁ X₂ : Type v
g₁ : AddCommGroup X₁
g₂ : AddCommGroup X₂
m₁ : Module R X₁
m₂ : Module R X₂
e : X₁ ≃ₗ[R] X₂
x✝ : ↑(ModuleCat.of R X₂)
⊢ (↑e.symm ≫ ↑e) x✝ = (𝟙 (ModuleCat.of R X₂)) x✝
state_after: no goals
tactic: apply e.right_inv
Theorem: Set.Countable.measure_zero
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝¹ : NoAtoms μ✝
h : s.Countable
μ : Measure α
inst✝ : NoAtoms μ
⊢ μ s = 0
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝¹ : NoAtoms μ✝
h : s.Countable
μ : Measure α
inst✝ : NoAtoms μ
⊢ ∀ i ∈ s, μ {i} = 0
tactic: rw [← biUnion_of_singleton s, measure_biUnion_null_iff h]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝¹ : NoAtoms μ✝
h : s.Countable
μ : Measure α
inst✝ : NoAtoms μ
⊢ ∀ i ∈ s, μ {i} = 0
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Functor.mapTriangleRotateIso_hom_app_hom₃
File: Mathlib/CategoryTheory/Triangulated/Functor.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
T : Triangle C
⊢ ((F.mapTriangle ⋙ rotate D).obj T).mor₁ ≫ (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂).hom =
    (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁).hom ≫ ((rotate C ⋙ F.mapTriangle).obj T).mor₁
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
T : Triangle C
⊢ ((F.mapTriangle ⋙ rotate D).obj T).mor₂ ≫ ((F.commShiftIso 1).symm.app T.obj₁).hom =
    (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂).hom ≫ ((rotate C ⋙ F.mapTriangle).obj T).mor₂
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
T : Triangle C
⊢ ((F.mapTriangle ⋙ rotate D).obj T).mor₃ ≫
      (shiftFunctor D 1).map (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁).hom =
    ((F.commShiftIso 1).symm.app T.obj₁).hom ≫ ((rotate C ⋙ F.mapTriangle).obj T).mor₃
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
⊢ ∀ {X Y : Triangle C} (f : X ⟶ Y),
    (F.mapTriangle ⋙ rotate D).map f ≫
        ((fun T =>
              ((F.mapTriangle ⋙ rotate D).obj T).isoMk ((rotate C ⋙ F.mapTriangle).obj T)
                (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁) (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂)
                ((F.commShiftIso 1).symm.app T.obj₁) ⋯ ⋯ ⋯)
            Y).hom =
      ((fun T =>
              ((F.mapTriangle ⋙ rotate D).obj T).isoMk ((rotate C ⋙ F.mapTriangle).obj T)
                (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁) (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂)
                ((F.commShiftIso 1).symm.app T.obj₁) ⋯ ⋯ ⋯)
            X).hom ≫
        (rotate C ⋙ F.mapTriangle).map f
state_after: no goals
tactic: aesop_cat
Theorem: List.Nodup.rotate_eq_self_iff
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l : List α
hl : l.Nodup
n : ℕ
⊢ l.rotate n = l ↔ n % l.length = 0 ∨ l = []
state_after: no goals
tactic: rw [← zero_mod, ← hl.rotate_congr_iff, rotate_zero]
Theorem: Matrix.vecAlt0_vecAppend
File: Mathlib/Data/Fin/VecNotation.lean

Proof steps:
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
⊢ vecAlt0 ⋯ (vecAppend ⋯ v v) = v ∘ fun n_1 => n_1 + n_1
state_after: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
⊢ vecAlt0 ⋯ (vecAppend ⋯ v v) i = (v ∘ fun n_1 => n_1 + n_1) i
tactic: ext i
state_before: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
⊢ vecAlt0 ⋯ (vecAppend ⋯ v v) i = (v ∘ fun n_1 => n_1 + n_1) i
state_after: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
⊢ (if h : ↑i + ↑i < n then v ⟨↑i + ↑i, ⋯⟩ else v ⟨↑i + ↑i - n, ⋯⟩) = v (i + i)
tactic: simp_rw [Function.comp, vecAlt0, vecAppend_eq_ite]
state_before: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
⊢ (if h : ↑i + ↑i < n then v ⟨↑i + ↑i, ⋯⟩ else v ⟨↑i + ↑i - n, ⋯⟩) = v (i + i)
state_after: case pos.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : ↑i + ↑i < n
⊢ ↑i + ↑i = (↑i + ↑i) % n

case neg.e_a.e_val
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin n → α
i : Fin n
h : ¬↑i + ↑i < n
⊢ ↑i + ↑i - n = (↑i + ↑i) % n
tactic: split_ifs with h <;> congr
Theorem: List.sublistsAux_eq_bind
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ sublistsAux a [] = [].bind fun l => [l, a :: l]
state_after: no goals
tactic: simp [sublistsAux]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r✝ r : List (List α)
l : List α
ih : sublistsAux a r = r.bind fun l => [l, a :: l]
⊢ sublistsAux a (r ++ [l]) = (r ++ [l]).bind fun l => [l, a :: l]
state_after: α : Type u
β : Type v
γ : Type w
a : α
r✝ r : List (List α)
l : List α
ih : sublistsAux a r = r.bind fun l => [l, a :: l]
⊢ foldl (fun r l => r ++ [l, a :: l]) (foldl (fun r l => r ++ [l, a :: l]) [] r) [l] = sublistsAux a r ++ [l, a :: l]
tactic: rw [append_bind, ← ih, bind_singleton, sublistsAux, foldl_append]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r✝ r : List (List α)
l : List α
ih : sublistsAux a r = r.bind fun l => [l, a :: l]
⊢ foldl (fun r l => r ++ [l, a :: l]) (foldl (fun r l => r ++ [l, a :: l]) [] r) [l] = sublistsAux a r ++ [l, a :: l]
state_after: no goals
tactic: simp [sublistsAux]
Theorem: KaehlerDifferential.kerTotal_mkQ_single_smul
File: Mathlib/RingTheory/Kaehler/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
r : R
x y : S
⊢ (y𝖣r • x) = r • y𝖣x
state_after: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
r : R
x y : S
this : SMulZeroClass R S := inferInstance
⊢ (y𝖣r • x) = r • y𝖣x
tactic: letI : SMulZeroClass R S := inferInstance
state_before: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
r : R
x y : S
this : SMulZeroClass R S := inferInstance
⊢ (y𝖣r • x) = r • y𝖣x
state_after: no goals
tactic: rw [Algebra.smul_def, KaehlerDifferential.kerTotal_mkQ_single_mul,
    KaehlerDifferential.kerTotal_mkQ_single_algebraMap, add_zero, ← LinearMap.map_smul_of_tower,
    Finsupp.smul_single, mul_comm, Algebra.smul_def]
Theorem: FirstOrder.Ring.realize_neg
File: Mathlib/ModelTheory/Algebra/Ring/Basic.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝⁵ : Add R
inst✝⁴ : Mul R
inst✝³ : Neg R
inst✝² : One R
inst✝¹ : Zero R
inst✝ : CompatibleRing R
x : ring.Term α
v : α → R
⊢ Term.realize v (-x) = -Term.realize v x
state_after: no goals
tactic: simp [neg_def, funMap_neg]