ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: WittVector.liftEquiv_apply
File: Mathlib/RingTheory/WittVector/Truncated.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : Semiring S
f : (k : ℕ) → S →+* TruncatedWittVector p k R
f_compat : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁
g : S →+* 𝕎 R
⊢ ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂),
    (TruncatedWittVector.truncate hk).comp ((fun k => (truncate k).comp g) k₂) = (fun k => (truncate k).comp g) k₁
state_after: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : Semiring S
f : (k : ℕ) → S →+* TruncatedWittVector p k R
f_compat : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁
g : S →+* 𝕎 R
k₁✝ k₂✝ : ℕ
h : k₁✝ ≤ k₂✝
⊢ (TruncatedWittVector.truncate h).comp ((fun k => (truncate k).comp g) k₂✝) = (fun k => (truncate k).comp g) k₁✝
tactic: intro _ _ h
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : Semiring S
f : (k : ℕ) → S →+* TruncatedWittVector p k R
f_compat : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁
g : S →+* 𝕎 R
k₁✝ k₂✝ : ℕ
h : k₁✝ ≤ k₂✝
⊢ (TruncatedWittVector.truncate h).comp ((fun k => (truncate k).comp g) k₂✝) = (fun k => (truncate k).comp g) k₁✝
state_after: no goals
tactic: simp only [← RingHom.comp_assoc, truncate_comp_wittVector_truncate]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : Semiring S
f : (k : ℕ) → S →+* TruncatedWittVector p k R
f_compat : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁
⊢ Function.LeftInverse (fun g => ⟨fun k => (truncate k).comp g, ⋯⟩) fun f => lift ↑f ⋯
state_after: case mk
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : Semiring S
f✝ : (k : ℕ) → S →+* TruncatedWittVector p k R
f_compat : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f✝ k₂) = f✝ k₁
f : (k : ℕ) → S →+* TruncatedWittVector p k R
hf : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁
⊢ (fun g => ⟨fun k => (truncate k).comp g, ⋯⟩) ((fun f => lift ↑f ⋯) ⟨f, hf⟩) = ⟨f, hf⟩
tactic: rintro ⟨f, hf⟩
state_before: case mk
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝¹ : CommRing R
S : Type u_2
inst✝ : Semiring S
f✝ : (k : ℕ) → S →+* TruncatedWittVector p k R
f_compat : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f✝ k₂) = f✝ k₁
f : (k : ℕ) → S →+* TruncatedWittVector p k R
hf : ∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁
⊢ (fun g => ⟨fun k => (truncate k).comp g, ⋯⟩) ((fun f => lift ↑f ⋯) ⟨f, hf⟩) = ⟨f, hf⟩
state_after: no goals
tactic: simp only [truncate_comp_lift]
Theorem: IsCoprime.ne_zero_or_ne_zero
File: Mathlib/RingTheory/Coprime/Basic.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
x y z : R
inst✝ : Nontrivial R
h : IsCoprime x y
⊢ x ≠ 0 ∨ y ≠ 0
state_after: case a
R : Type u
inst✝¹ : CommSemiring R
x y z : R
inst✝ : Nontrivial R
h : IsCoprime x y
⊢ x = 0 → y ≠ 0
tactic: apply not_or_of_imp
state_before: case a
R : Type u
inst✝¹ : CommSemiring R
x y z : R
inst✝ : Nontrivial R
h : IsCoprime x y
⊢ x = 0 → y ≠ 0
state_after: case a
R : Type u
inst✝¹ : CommSemiring R
z : R
inst✝ : Nontrivial R
h : IsCoprime 0 0
⊢ False
tactic: rintro rfl rfl
state_before: case a
R : Type u
inst✝¹ : CommSemiring R
z : R
inst✝ : Nontrivial R
h : IsCoprime 0 0
⊢ False
state_after: no goals
tactic: exact not_isCoprime_zero_zero h
Theorem: CategoryTheory.oppositeShiftFunctorZero_hom_app
File: Mathlib/CategoryTheory/Shift/Opposite.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_3, u_1} C
A : Type u_2
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X : OppositeShift C A
⊢ (shiftFunctorZero (OppositeShift C A) A).hom.app X = ((shiftFunctorZero C A).inv.app (Opposite.unop X)).op
state_after: C : Type u_1
inst✝² : Category.{u_3, u_1} C
A : Type u_2
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X : OppositeShift C A
⊢ 𝟙 ((shiftFunctor (OppositeShift C A) 0).obj X) = 𝟙 (Opposite.op ((shiftFunctor C 0).obj (Opposite.unop X)))
tactic: rw [← cancel_mono ((shiftFunctorZero (OppositeShift C A) A).inv.app X),
    Iso.hom_inv_id_app, oppositeShiftFunctorZero_inv_app, ← op_comp,
    Iso.hom_inv_id_app, op_id]
state_before: C : Type u_1
inst✝² : Category.{u_3, u_1} C
A : Type u_2
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X : OppositeShift C A
⊢ 𝟙 ((shiftFunctor (OppositeShift C A) 0).obj X) = 𝟙 (Opposite.op ((shiftFunctor C 0).obj (Opposite.unop X)))
state_after: no goals
tactic: rfl
Theorem: frontier_closedBall'
File: Mathlib/Analysis/NormedSpace/Real.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
r : ℝ
⊢ frontier (closedBall x r) = sphere x r
state_after: no goals
tactic: rw [frontier, closure_closedBall, interior_closedBall' x r, closedBall_diff_ball]
Theorem: birkhoffAverage_zero
File: Mathlib/Dynamics/BirkhoffSum/Average.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
M : Type u_3
inst✝² : DivisionSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : α → α
g : α → M
x : α
⊢ birkhoffAverage R f g 0 x = 0
state_after: no goals
tactic: simp [birkhoffAverage]
Theorem: Filter.rtendsto_iff_le_rcomap
File: Mathlib/Order/Filter/Partial.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ RTendsto r l₁ l₂ ↔ l₁ ≤ rcomap r l₂
state_after: α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ (∀ s ∈ l₂, r.core s ∈ l₁) ↔ l₁ ≤ rcomap r l₂
tactic: rw [rtendsto_def]
state_before: α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ (∀ s ∈ l₂, r.core s ∈ l₁) ↔ l₁ ≤ rcomap r l₂
state_after: α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ (∀ s ∈ l₂.sets, r.core s ∈ l₁) ↔ l₁ ≤ rcomap r l₂
tactic: simp_rw [← l₂.mem_sets]
state_before: α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ (∀ s ∈ l₂.sets, r.core s ∈ l₁) ↔ l₁ ≤ rcomap r l₂
state_after: case mp
α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ (∀ s ∈ l₂.sets, r.core s ∈ l₁) → l₁ ≤ rcomap r l₂

case mpr
α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ l₁ ≤ rcomap r l₂ → ∀ s ∈ l₂.sets, r.core s ∈ l₁
tactic: constructor
Theorem: Submodule.card_eq_card_quotient_mul_card
File: Mathlib/LinearAlgebra/Quotient.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' S : Submodule R M
⊢ Nat.card M = Nat.card ↥S * Nat.card (M ⧸ S)
state_after: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' S : Submodule R M
⊢ Nat.card M = Nat.card ((M ⧸ S) × ↥S)
tactic: rw [mul_comm, ← Nat.card_prod]
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' S : Submodule R M
⊢ Nat.card M = Nat.card ((M ⧸ S) × ↥S)
state_after: no goals
tactic: exact Nat.card_congr AddSubgroup.addGroupEquivQuotientProdAddSubgroup
Theorem: ZNum.dvd_iff_mod_eq_zero
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: m n : ZNum
⊢ m ∣ n ↔ n % m = 0
state_after: m n : ZNum
⊢ ↑n % ↑m = 0 ↔ ↑n % ↑m = ↑0
tactic: rw [← dvd_to_int, Int.dvd_iff_emod_eq_zero, ← to_int_inj, mod_to_int]
state_before: m n : ZNum
⊢ ↑n % ↑m = 0 ↔ ↑n % ↑m = ↑0
state_after: no goals
tactic: rfl
Theorem: fderivWithin_inv'
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s✝ t : Set E
L L₁ L₂ : Filter E
R : Type u_6
inst✝² : NormedDivisionRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
s : Set R
x : R
hx : x ≠ 0
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ fderivWithin 𝕜 (fun x => x⁻¹) s x = -((mulLeftRight 𝕜 R) x⁻¹) x⁻¹
state_after: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s✝ t : Set E
L L₁ L₂ : Filter E
R : Type u_6
inst✝² : NormedDivisionRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
s : Set R
x : R
hx : x ≠ 0
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ fderiv 𝕜 Inv.inv x = -((mulLeftRight 𝕜 R) x⁻¹) x⁻¹
tactic: rw [DifferentiableAt.fderivWithin (differentiableAt_inv' hx) hxs]
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s✝ t : Set E
L L₁ L₂ : Filter E
R : Type u_6
inst✝² : NormedDivisionRing R
inst✝¹ : NormedAlgebra 𝕜 R
inst✝ : CompleteSpace R
s : Set R
x : R
hx : x ≠ 0
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ fderiv 𝕜 Inv.inv x = -((mulLeftRight 𝕜 R) x⁻¹) x⁻¹
state_after: no goals
tactic: exact fderiv_inv' hx
Theorem: List.erase_orderedInsert_of_not_mem
File: Mathlib/Data/List/Sort.lean

Proof steps:
state_before: α : Type u
r : α → α → Prop
inst✝¹ : DecidableRel r
inst✝ : DecidableEq α
x : α
xs : List α
hx : x ∉ xs
⊢ (orderedInsert r x xs).erase x = xs
state_after: case h
α : Type u
r : α → α → Prop
inst✝¹ : DecidableRel r
inst✝ : DecidableEq α
x : α
xs : List α
hx : x ∉ xs
⊢ x ∉ takeWhile (fun b => decide ¬r x b) xs
tactic: rw [orderedInsert_eq_take_drop, erase_append_right, List.erase_cons_head,
    takeWhile_append_dropWhile]
Theorem: HahnSeries.embDomain_mul
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

Proof steps:
state_before: Γ : Type u_1
Γ'✝ : Type u_2
R : Type u_3
V : Type u_4
inst✝² : OrderedCancelAddCommMonoid Γ
Γ' : Type u_5
inst✝¹ : OrderedCancelAddCommMonoid Γ'
inst✝ : NonUnitalNonAssocSemiring R
f : Γ ↪o Γ'
hf : ∀ (x y : Γ), f (x + y) = f x + f y
x y : HahnSeries Γ R
⊢ embDomain f (x * y) = embDomain f x * embDomain f y
state_after: case coeff.h
Γ : Type u_1
Γ'✝ : Type u_2
R : Type u_3
V : Type u_4
inst✝² : OrderedCancelAddCommMonoid Γ
Γ' : Type u_5
inst✝¹ : OrderedCancelAddCommMonoid Γ'
inst✝ : NonUnitalNonAssocSemiring R
f : Γ ↪o Γ'
hf : ∀ (x y : Γ), f (x + y) = f x + f y
x y : HahnSeries Γ R
g : Γ'
⊢ (embDomain f (x * y)).coeff g = (embDomain f x * embDomain f y).coeff g
tactic: ext g
state_before: case coeff.h
Γ : Type u_1
Γ'✝ : Type u_2
R : Type u_3
V : Type u_4
inst✝² : OrderedCancelAddCommMonoid Γ
Γ' : Type u_5
inst✝¹ : OrderedCancelAddCommMonoid Γ'
inst✝ : NonUnitalNonAssocSemiring R
f : Γ ↪o Γ'
hf : ∀ (x y : Γ), f (x + y) = f x + f y
x y : HahnSeries Γ R
g : Γ'
⊢ (embDomain f (x * y)).coeff g = (embDomain f x * embDomain f y).coeff g
state_after: case pos
Γ : Type u_1
Γ'✝ : Type u_2
R : Type u_3
V : Type u_4
inst✝² : OrderedCancelAddCommMonoid Γ
Γ' : Type u_5
inst✝¹ : OrderedCancelAddCommMonoid Γ'
inst✝ : NonUnitalNonAssocSemiring R
f : Γ ↪o Γ'
hf : ∀ (x y : Γ), f (x + y) = f x + f y
x y : HahnSeries Γ R
g : Γ'
hg : g ∈ Set.range ⇑f
⊢ (embDomain f (x * y)).coeff g = (embDomain f x * embDomain f y).coeff g

case neg
Γ : Type u_1
Γ'✝ : Type u_2
R : Type u_3
V : Type u_4
inst✝² : OrderedCancelAddCommMonoid Γ
Γ' : Type u_5
inst✝¹ : OrderedCancelAddCommMonoid Γ'
inst✝ : NonUnitalNonAssocSemiring R
f : Γ ↪o Γ'
hf : ∀ (x y : Γ), f (x + y) = f x + f y
x y : HahnSeries Γ R
g : Γ'
hg : g ∉ Set.range ⇑f
⊢ (embDomain f (x * y)).coeff g = (embDomain f x * embDomain f y).coeff g
tactic: by_cases hg : g ∈ Set.range f
Theorem: geom_sum_neg_iff
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α : Type u
β : Type u_1
n : ℕ
x : α
inst✝ : LinearOrderedRing α
hn : n ≠ 0
⊢ ∑ i ∈ range n, x ^ i < 0 ↔ Even n ∧ x + 1 < 0
state_after: no goals
tactic: rw [← not_iff_not, not_lt, le_iff_lt_or_eq, eq_comm,
    or_congr (geom_sum_pos_iff hn) (geom_sum_eq_zero_iff_neg_one hn), Nat.odd_iff_not_even, ←
    add_eq_zero_iff_eq_neg, not_and, not_lt, le_iff_lt_or_eq, eq_comm, ← imp_iff_not_or, or_comm,
    and_comm, Decidable.and_or_imp, or_comm]
Theorem: Finset.dens_univ
File: Mathlib/Data/Finset/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : Fintype α
s t : Finset α
a b : α
inst✝ : Nonempty α
⊢ univ.dens = 1
state_after: no goals
tactic: simp [dens, card_univ]
Theorem: CategoryTheory.CostructuredArrow.post_obj
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S✝ S' : C ⥤ D
A : Type u₃
inst✝¹ : Category.{v₃, u₃} A
B : Type u₄
inst✝ : Category.{v₄, u₄} B
F : B ⥤ C
G : C ⥤ D
S : C
X✝ Y✝ : CostructuredArrow F S
f : X✝ ⟶ Y✝
⊢ (F ⋙ G).map f.left ≫ ((fun X => mk (G.map X.hom)) Y✝).hom = ((fun X => mk (G.map X.hom)) X✝).hom
state_after: no goals
tactic: simp [Functor.comp_map, ← G.map_comp, ← f.w]
Theorem: HahnSeries.leadingCoeff_add_eq_right
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ✝ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ✝
inst✝¹ : AddMonoid R
Γ : Type u_3
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
hxy : y.orderTop < x.orderTop
⊢ (x + y).leadingCoeff = y.leadingCoeff
state_after: no goals
tactic: simpa [← map_add, ← AddOpposite.op_add, hxy] using leadingCoeff_add_eq_left
    (x := addOppositeEquiv.symm (.op y))
    (y := addOppositeEquiv.symm (.op x))
Theorem: continuousWithinAt_insert_self
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
x : α
s : Set α
⊢ ContinuousWithinAt f (insert x s) x ↔ ContinuousWithinAt f s x
state_after: no goals
tactic: simp only [← singleton_union, continuousWithinAt_union, continuousWithinAt_singleton,
    true_and_iff]
Theorem: LinearRecurrence.geom_sol_iff_root_charPoly
File: Mathlib/Algebra/LinearRecurrence.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommRing α
E : LinearRecurrence α
q : α
⊢ (E.IsSolution fun n => q ^ n) ↔ E.charPoly.IsRoot q
state_after: α : Type u_1
inst✝ : CommRing α
E : LinearRecurrence α
q : α
⊢ (E.IsSolution fun n => q ^ n) ↔
    eval₂ (RingHom.id α) q ((monomial E.order) 1 - ∑ i : Fin E.order, (monomial ↑i) (E.coeffs i)) = 0
tactic: rw [charPoly, Polynomial.IsRoot.def, Polynomial.eval]
state_before: α : Type u_1
inst✝ : CommRing α
E : LinearRecurrence α
q : α
⊢ (E.IsSolution fun n => q ^ n) ↔
    eval₂ (RingHom.id α) q ((monomial E.order) 1 - ∑ i : Fin E.order, (monomial ↑i) (E.coeffs i)) = 0
state_after: α : Type u_1
inst✝ : CommRing α
E : LinearRecurrence α
q : α
⊢ (E.IsSolution fun n => q ^ n) ↔ q ^ E.order - ∑ x : Fin E.order, E.coeffs x * q ^ ↑x = 0
tactic: simp only [Polynomial.eval₂_finset_sum, one_mul, RingHom.id_apply, Polynomial.eval₂_monomial,
    Polynomial.eval₂_sub]
state_before: α : Type u_1
inst✝ : CommRing α
E : LinearRecurrence α
q : α
⊢ (E.IsSolution fun n => q ^ n) ↔ q ^ E.order - ∑ x : Fin E.order, E.coeffs x * q ^ ↑x = 0
state_after: case mp
α : Type u_1
inst✝ : CommRing α
E : LinearRecurrence α
q : α
⊢ (E.IsSolution fun n => q ^ n) → q ^ E.order - ∑ x : Fin E.order, E.coeffs x * q ^ ↑x = 0

case mpr
α : Type u_1
inst✝ : CommRing α
E : LinearRecurrence α
q : α
⊢ q ^ E.order - ∑ x : Fin E.order, E.coeffs x * q ^ ↑x = 0 → E.IsSolution fun n => q ^ n
tactic: constructor
Theorem: CategoryTheory.Limits.Types.Pushout.condition
File: Mathlib/CategoryTheory/Limits/Shapes/Types.lean

Proof steps:
state_before: S X₁ X₂ : Type u
f : S ⟶ X₁
g : S ⟶ X₂
⊢ f ≫ inl f g = g ≫ inr f g
state_after: case h
S X₁ X₂ : Type u
f : S ⟶ X₁
g : S ⟶ X₂
x : S
⊢ (f ≫ inl f g) x = (g ≫ inr f g) x
tactic: ext x
state_before: case h
S X₁ X₂ : Type u
f : S ⟶ X₁
g : S ⟶ X₂
x : S
⊢ (f ≫ inl f g) x = (g ≫ inr f g) x
state_after: no goals
tactic: exact Quot.sound (Rel.inl_inr x)
Theorem: MeasureTheory.Integrable.fintype_prod_dep
File: Mathlib/MeasureTheory/Integral/Pi.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
ι : Type u_2
inst✝² : Fintype ι
E : ι → Type u_3
f : (i : ι) → E i → 𝕜
inst✝¹ : (i : ι) → MeasureSpace (E i)
inst✝ : ∀ (i : ι), SigmaFinite volume
hf : ∀ (i : ι), Integrable (f i) volume
⊢ Integrable (fun x => ∏ i : ι, f i (x i)) volume
state_after: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
ι : Type u_2
inst✝² : Fintype ι
E : ι → Type u_3
f : (i : ι) → E i → 𝕜
inst✝¹ : (i : ι) → MeasureSpace (E i)
inst✝ : ∀ (i : ι), SigmaFinite volume
hf : ∀ (i : ι), Integrable (f i) volume
e : Fin (card ι) ≃ ι := (equivFin ι).symm
⊢ Integrable (fun x => ∏ i : ι, f i (x i)) volume
tactic: let e := (equivFin ι).symm
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
ι : Type u_2
inst✝² : Fintype ι
E : ι → Type u_3
f : (i : ι) → E i → 𝕜
inst✝¹ : (i : ι) → MeasureSpace (E i)
inst✝ : ∀ (i : ι), SigmaFinite volume
hf : ∀ (i : ι), Integrable (f i) volume
e : Fin (card ι) ≃ ι := (equivFin ι).symm
⊢ Integrable (fun x => ∏ i : ι, f i (x i)) volume
state_after: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
ι : Type u_2
inst✝² : Fintype ι
E : ι → Type u_3
f : (i : ι) → E i → 𝕜
inst✝¹ : (i : ι) → MeasureSpace (E i)
inst✝ : ∀ (i : ι), SigmaFinite volume
hf : ∀ (i : ι), Integrable (f i) volume
e : Fin (card ι) ≃ ι := (equivFin ι).symm
⊢ Integrable (fun x => ∏ x_1 : Fin (card ι), f (e x_1) (x x_1)) volume
tactic: simp_rw [← (volume_measurePreserving_piCongrLeft _ e).integrable_comp_emb
    (MeasurableEquiv.measurableEmbedding _),
    ← e.prod_comp, MeasurableEquiv.coe_piCongrLeft, Function.comp_def,
    Equiv.piCongrLeft_apply_apply]
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
ι : Type u_2
inst✝² : Fintype ι
E : ι → Type u_3
f : (i : ι) → E i → 𝕜
inst✝¹ : (i : ι) → MeasureSpace (E i)
inst✝ : ∀ (i : ι), SigmaFinite volume
hf : ∀ (i : ι), Integrable (f i) volume
e : Fin (card ι) ≃ ι := (equivFin ι).symm
⊢ Integrable (fun x => ∏ x_1 : Fin (card ι), f (e x_1) (x x_1)) volume
state_after: no goals
tactic: exact .fin_nat_prod (fun i ↦ hf _)
Theorem: NNReal.IsConjExponent.symm
File: Mathlib/Data/Real/ConjExponents.lean

Proof steps:
state_before: a b p q : ℝ≥0
h✝ h : p.IsConjExponent q
⊢ 1 < q
state_after: a b p q : ℝ≥0
h✝ h : p.IsConjExponent q
⊢ 1 < p / (p - 1)
tactic: rw [h.conj_eq]
state_before: a b p q : ℝ≥0
h✝ h : p.IsConjExponent q
⊢ 1 < p / (p - 1)
state_after: no goals
tactic: exact (one_lt_div h.sub_one_pos).mpr (tsub_lt_self h.pos zero_lt_one)
state_before: a b p q : ℝ≥0
h✝ h : p.IsConjExponent q
⊢ q⁻¹ + p⁻¹ = 1
state_after: no goals
tactic: simpa [add_comm] using h.inv_add_inv_conj
Theorem: ProbabilityTheory.measure_ge_le_exp_cgf
File: Mathlib/Probability/Moments.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : 0 ≤ t
h_int : Integrable (fun ω => rexp (t * X ω)) μ
⊢ (μ {ω | ε ≤ X ω}).toReal ≤ rexp (-t * ε + cgf X μ t)
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : 0 ≤ t
h_int : Integrable (fun ω => rexp (t * X ω)) μ
⊢ rexp (-t * ε) * mgf X μ t ≤ rexp (-t * ε + cgf X μ t)
tactic: refine (measure_ge_le_exp_mul_mgf ε ht h_int).trans ?_
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : 0 ≤ t
h_int : Integrable (fun ω => rexp (t * X ω)) μ
⊢ rexp (-t * ε) * mgf X μ t ≤ rexp (-t * ε + cgf X μ t)
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : 0 ≤ t
h_int : Integrable (fun ω => rexp (t * X ω)) μ
⊢ rexp (-t * ε) * mgf X μ t ≤ rexp (-t * ε) * rexp (cgf X μ t)
tactic: rw [exp_add]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : 0 ≤ t
h_int : Integrable (fun ω => rexp (t * X ω)) μ
⊢ rexp (-t * ε) * mgf X μ t ≤ rexp (-t * ε) * rexp (cgf X μ t)
state_after: no goals
tactic: exact mul_le_mul le_rfl (le_exp_log _) mgf_nonneg (exp_pos _).le
Theorem: ProbabilityTheory.Kernel.isSFiniteKernel_prodMkLeft_unit
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : Kernel α β
⊢ IsSFiniteKernel (prodMkLeft Unit κ) ↔ IsSFiniteKernel κ
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : Kernel α β
x✝ : IsSFiniteKernel (prodMkLeft Unit κ)
⊢ IsSFiniteKernel κ
tactic: refine ⟨fun _ ↦ ?_, fun _ ↦ inferInstance⟩
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : Kernel α β
x✝ : IsSFiniteKernel (prodMkLeft Unit κ)
⊢ IsSFiniteKernel κ
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : Kernel α β
x✝ : IsSFiniteKernel (prodMkLeft Unit κ)
⊢ IsSFiniteKernel ((prodMkLeft Unit κ).comap (fun a => ((), a)) ⋯)
tactic: change IsSFiniteKernel ((prodMkLeft Unit κ).comap (fun a ↦ ((), a)) (by fun_prop))
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : Kernel α β
x✝ : IsSFiniteKernel (prodMkLeft Unit κ)
⊢ IsSFiniteKernel ((prodMkLeft Unit κ).comap (fun a => ((), a)) ⋯)
state_after: no goals
tactic: infer_instance
Theorem: Int.closedBall_eq_Icc
File: Mathlib/Topology/Instances/Int.lean

Proof steps:
state_before: x : ℤ
r : ℝ
⊢ closedBall x r = Icc ⌈↑x - r⌉ ⌊↑x + r⌋
state_after: no goals
tactic: rw [← preimage_closedBall, Real.closedBall_eq_Icc, preimage_Icc]
Theorem: Multiset.rel_cons_left
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
a : α
as : Multiset α
bs : Multiset β
⊢ Rel r (a ::ₘ as) bs ↔ ∃ b bs', r a b ∧ Rel r as bs' ∧ bs = b ::ₘ bs'
state_after: case mp
α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
a : α
as : Multiset α
bs : Multiset β
⊢ Rel r (a ::ₘ as) bs → ∃ b bs', r a b ∧ Rel r as bs' ∧ bs = b ::ₘ bs'

case mpr
α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
a : α
as : Multiset α
bs : Multiset β
⊢ (∃ b bs', r a b ∧ Rel r as bs' ∧ bs = b ::ₘ bs') → Rel r (a ::ₘ as) bs
tactic: constructor
Theorem: RingHom.surjective_stableUnderComposition
File: Mathlib/RingTheory/RingHom/Surjective.lean

Proof steps:
state_before: ⊢ StableUnderComposition fun {X Y} [CommRing X] [CommRing Y] f => Function.Surjective ⇑f
state_after: R S T : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
f : R →+* S
g : S →+* T
hf : Function.Surjective ⇑f
hg : Function.Surjective ⇑g
⊢ Function.Surjective ⇑(g.comp f)
tactic: introv R hf hg
state_before: R S T : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
f : R →+* S
g : S →+* T
hf : Function.Surjective ⇑f
hg : Function.Surjective ⇑g
⊢ Function.Surjective ⇑(g.comp f)
state_after: no goals
tactic: exact hg.comp hf