1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.Measure.comapₗ_apply
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [comapₗ, dif_pos, liftLinear_apply _ hs, OuterMeasure.comap_apply, coe_toOuterMeasure]
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f✝ : α → β✝
β : Type u_8
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)
μ : Measure β
hs : MeasurableSet s
⊢ ((comapₗ f) μ) s = μ (f '' s)
state_after: case hc
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f✝ : α → β✝
β : Type u_8
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)
μ : Measure β
hs : MeasurableSet s
⊢ Injective f ∧ ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)

case hc
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f✝ : α → β✝
β : Type u_8
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)
μ : Measure β
hs : MeasurableSet s
⊢ Injective f ∧ ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)

tactic: exact ⟨hfi, hf⟩
state_before: case hc
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f✝ : α → β✝
β : Type u_8
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)
μ : Measure β
hs : MeasurableSet s
⊢ Injective f ∧ ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)

case hc
α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f✝ : α → β✝
β : Type u_8
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)
μ : Measure β
hs : MeasurableSet s
⊢ Injective f ∧ ∀ (s : Set α), MeasurableSet s → MeasurableSet (f '' s)
state_after: no goals
Theorem: prod_eq_tprod_mulIndicator
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: rw [tprod_eq_prod' (Set.mulSupport_mulIndicator_subset),
    Finset.prod_mulIndicator_subset _ Finset.Subset.rfl]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
f : β → α
s : Finset β
⊢ ∏ x ∈ s, f x = ∏' (x : β), (↑s).mulIndicator f x
state_after: no goals
Theorem: MeasureTheory.setAverage_eq
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: rw [average_eq, restrict_apply_univ]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s✝ t : Set α
f✝ g f : α → E
s : Set α
⊢ ⨍ (x : α) in s, f x ∂μ = (μ s).toReal⁻¹ • ∫ (x : α) in s, f x ∂μ
state_after: no goals
Theorem: CategoryTheory.Groupoid.Free.congr_reverse_comp
File: Mathlib/CategoryTheory/Groupoid/FreeGroupoid.lean

tactic: nth_rw 2 [← Quiver.Path.reverse_reverse p]
state_before: V : Type u
inst✝ : Quiver V
X Y : Paths (Quiver.Symmetrify V)
p : X ⟶ Y
⊢ Quot.mk (Quotient.CompClosure redStep) (Quiver.Path.reverse p ≫ p) = Quot.mk (Quotient.CompClosure redStep) (𝟙 Y)
state_after: V : Type u
inst✝ : Quiver V
X Y : Paths (Quiver.Symmetrify V)
p : X ⟶ Y
⊢ Quot.mk (Quotient.CompClosure redStep) (Quiver.Path.reverse p ≫ (Quiver.Path.reverse p).reverse) =
    Quot.mk (Quotient.CompClosure redStep) (𝟙 Y)

tactic: apply congr_comp_reverse
state_before: V : Type u
inst✝ : Quiver V
X Y : Paths (Quiver.Symmetrify V)
p : X ⟶ Y
⊢ Quot.mk (Quotient.CompClosure redStep) (Quiver.Path.reverse p ≫ (Quiver.Path.reverse p).reverse) =
    Quot.mk (Quotient.CompClosure redStep) (𝟙 Y)
state_after: no goals
Theorem: Submodule.ClosedComplemented.isClosed
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: rcases h with ⟨f, hf⟩
state_before: R : Type u_1
inst✝⁸ : Ring R
M : Type u_2
inst✝⁷ : TopologicalSpace M
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M₂ : Type u_3
inst✝⁴ : TopologicalSpace M₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : TopologicalAddGroup M
inst✝ : T1Space M
p : Submodule R M
h : p.ClosedComplemented
⊢ IsClosed ↑p
state_after: case intro
R : Type u_1
inst✝⁸ : Ring R
M : Type u_2
inst✝⁷ : TopologicalSpace M
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M₂ : Type u_3
inst✝⁴ : TopologicalSpace M₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : TopologicalAddGroup M
inst✝ : T1Space M
p : Submodule R M
f : M →L[R] ↥p
hf : ∀ (x : ↥p), f ↑x = x
⊢ IsClosed ↑p

tactic: have : ker (id R M - p.subtypeL.comp f) = p := LinearMap.ker_id_sub_eq_of_proj hf
state_before: case intro
R : Type u_1
inst✝⁸ : Ring R
M : Type u_2
inst✝⁷ : TopologicalSpace M
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M₂ : Type u_3
inst✝⁴ : TopologicalSpace M₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : TopologicalAddGroup M
inst✝ : T1Space M
p : Submodule R M
f : M →L[R] ↥p
hf : ∀ (x : ↥p), f ↑x = x
⊢ IsClosed ↑p
state_after: case intro
R : Type u_1
inst✝⁸ : Ring R
M : Type u_2
inst✝⁷ : TopologicalSpace M
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M₂ : Type u_3
inst✝⁴ : TopologicalSpace M₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : TopologicalAddGroup M
inst✝ : T1Space M
p : Submodule R M
f : M →L[R] ↥p
hf : ∀ (x : ↥p), f ↑x = x
this : LinearMap.ker (ContinuousLinearMap.id R M - p.subtypeL.comp f) = p
⊢ IsClosed ↑p

tactic: exact this ▸ isClosed_ker _
state_before: case intro
R : Type u_1
inst✝⁸ : Ring R
M : Type u_2
inst✝⁷ : TopologicalSpace M
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M₂ : Type u_3
inst✝⁴ : TopologicalSpace M₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : TopologicalAddGroup M
inst✝ : T1Space M
p : Submodule R M
f : M →L[R] ↥p
hf : ∀ (x : ↥p), f ↑x = x
this : LinearMap.ker (ContinuousLinearMap.id R M - p.subtypeL.comp f) = p
⊢ IsClosed ↑p
state_after: no goals
Theorem: CategoryTheory.NatTrans.rightDerived_comp
File: Mathlib/CategoryTheory/Abelian/RightDerived.lean

tactic: simp [NatTrans.rightDerived]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
D : Type u_1
inst✝⁶ : Category.{u_2, u_1} D
inst✝⁵ : Abelian C
inst✝⁴ : HasInjectiveResolutions C
inst✝³ : Abelian D
F G H : C ⥤ D
inst✝² : F.Additive
inst✝¹ : G.Additive
inst✝ : H.Additive
α : F ⟶ G
β : G ⟶ H
n : ℕ
⊢ rightDerived (α ≫ β) n = rightDerived α n ≫ rightDerived β n
state_after: no goals
Theorem: IsClosed.analyticSet
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: haveI : PolishSpace s := hs.polishSpace
state_before: α : Type u_1
ι : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsClosed s
⊢ AnalyticSet s
state_after: α : Type u_1
ι : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsClosed s
this : PolishSpace ↑s
⊢ AnalyticSet s

tactic: rw [← @Subtype.range_val α s]
state_before: α : Type u_1
ι : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsClosed s
this : PolishSpace ↑s
⊢ AnalyticSet s
state_after: α : Type u_1
ι : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsClosed s
this : PolishSpace ↑s
⊢ AnalyticSet (range Subtype.val)

tactic: exact analyticSet_range_of_polishSpace continuous_subtype_val
state_before: α : Type u_1
ι : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsClosed s
this : PolishSpace ↑s
⊢ AnalyticSet (range Subtype.val)
state_after: no goals
Theorem: Finset.eraseNone_map_some
File: Mathlib/Data/Finset/Option.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
s : Finset α
⊢ eraseNone (map Embedding.some s) = s
state_after: case a
α : Type u_1
β : Type u_2
s : Finset α
a✝ : α
⊢ a✝ ∈ eraseNone (map Embedding.some s) ↔ a✝ ∈ s

tactic: simp
state_before: case a
α : Type u_1
β : Type u_2
s : Finset α
a✝ : α
⊢ a✝ ∈ eraseNone (map Embedding.some s) ↔ a✝ ∈ s
state_after: no goals
Theorem: MeasureTheory.ProbabilityMeasure.apply_le_one
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: simpa using apply_mono μ (subset_univ s)
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : ProbabilityMeasure Ω
s : Set Ω
⊢ μ s ≤ 1
state_after: no goals
Theorem: KummerDedekind.multiplicity_factors_map_eq_multiplicity
File: Mathlib/NumberTheory/KummerDedekind.lean

tactic: rw [normalizedFactorsMapEquivNormalizedFactorsMinPolyMk, Equiv.coe_trans, Function.comp_apply,
  multiplicity_normalizedFactorsEquivSpanNormalizedFactors_symm_eq_multiplicity,
  normalizedFactorsEquivOfQuotEquiv_multiplicity_eq_multiplicity]
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
x : S
I : Ideal R
inst✝³ : IsDomain R
inst✝² : IsIntegrallyClosed R
inst✝¹ : IsDedekindDomain S
inst✝ : NoZeroSMulDivisors R S
hI : I.IsMaximal
hI' : I ≠ ⊥
hx : comap (algebraMap R S) (conductor R x) ⊔ I = ⊤
hx' : _root_.IsIntegral R x
J : Ideal S
hJ : J ∈ normalizedFactors (Ideal.map (algebraMap R S) I)
⊢ multiplicity J (Ideal.map (algebraMap R S) I) =
    multiplicity (↑((normalizedFactorsMapEquivNormalizedFactorsMinPolyMk hI hI' hx hx') ⟨J, hJ⟩))
      (Polynomial.map (Ideal.Quotient.mk I) (minpoly R x))
state_after: no goals
Theorem: Behrend.sphere_zero_subset
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

tactic: simp [sphere, Function.funext_iff]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ x : Fin n → ℕ
⊢ x ∈ sphere n d 0 → x ∈ 0
state_after: no goals
Theorem: DFinsupp.mk_smul
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: simp only [smul_apply, mk_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
s : Finset ι
c : γ
x : (i : ↑↑s) → β ↑i
i : ι
⊢ (mk s (c • x)) i = (c • mk s x) i
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
s : Finset ι
c : γ
x : (i : ↑↑s) → β ↑i
i : ι
⊢ (if H : i ∈ s then (c • x) ⟨i, H⟩ else 0) = c • if H : i ∈ s then x ⟨i, H⟩ else 0

tactic: split_ifs <;> [rfl; rw [smul_zero]]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : Monoid γ
inst✝¹ : (i : ι) → AddMonoid (β i)
inst✝ : (i : ι) → DistribMulAction γ (β i)
s : Finset ι
c : γ
x : (i : ↑↑s) → β ↑i
i : ι
⊢ (if H : i ∈ s then (c • x) ⟨i, H⟩ else 0) = c • if H : i ∈ s then x ⟨i, H⟩ else 0
state_after: no goals
Theorem: Matroid.Indep.exists_insert_of_not_mem_maximals
File: Mathlib/Data/Matroid/Basic.lean

tactic: simp only [mem_maximals_iff, mem_setOf_eq, not_and, not_forall, exists_prop,
  exists_and_left, iff_true_intro hI, true_imp_iff] at hB hInotmax
state_before: α : Type u_1
M✝ M : Matroid α
I B : Set α
hI : M.Indep I
hInotmax : I ∉ maximals (fun x x_1 => x ⊆ x_1) {I | M.Indep I}
hB : B ∈ maximals (fun x x_1 => x ⊆ x_1) {I | M.Indep I}
⊢ ∃ x ∈ B \ I, M.Indep (insert x I)
state_after: α : Type u_1
M✝ M : Matroid α
I B : Set α
hI : M.Indep I
hB : M.Indep B ∧ ∀ ⦃y : Set α⦄, M.Indep y → B ⊆ y → B = y
hInotmax : ∃ x, M.Indep x ∧ I ⊆ x ∧ ¬I = x
⊢ ∃ x ∈ B \ I, M.Indep (insert x I)

tactic: refine hI.exists_insert_of_not_base (fun hIb ↦ ?_) ?_
state_before: α : Type u_1
M✝ M : Matroid α
I B : Set α
hI : M.Indep I
hB : M.Indep B ∧ ∀ ⦃y : Set α⦄, M.Indep y → B ⊆ y → B = y
hInotmax : ∃ x, M.Indep x ∧ I ⊆ x ∧ ¬I = x
⊢ ∃ x ∈ B \ I, M.Indep (insert x I)
state_after: case refine_1
α : Type u_1
M✝ M : Matroid α
I B : Set α
hI : M.Indep I
hB : M.Indep B ∧ ∀ ⦃y : Set α⦄, M.Indep y → B ⊆ y → B = y
hInotmax : ∃ x, M.Indep x ∧ I ⊆ x ∧ ¬I = x
hIb : M.Base I
⊢ False

case refine_2
α : Type u_1
M✝ M : Matroid α
I B : Set α
hI : M.Indep I
hB : M.Indep B ∧ ∀ ⦃y : Set α⦄, M.Indep y → B ⊆ y → B = y
hInotmax : ∃ x, M.Indep x ∧ I ⊆ x ∧ ¬I = x
⊢ M.Base B

tactic: exact hB.1.base_of_maximal fun J hJ hBJ ↦ hB.2 hJ hBJ
state_before: case refine_2
α : Type u_1
M✝ M : Matroid α
I B : Set α
hI : M.Indep I
hB : M.Indep B ∧ ∀ ⦃y : Set α⦄, M.Indep y → B ⊆ y → B = y
hInotmax : ∃ x, M.Indep x ∧ I ⊆ x ∧ ¬I = x
⊢ M.Base B
state_after: no goals

tactic: obtain ⟨I', hII', hI', hne⟩ := hInotmax
state_before: case refine_1
α : Type u_1
M✝ M : Matroid α
I B : Set α
hI : M.Indep I
hB : M.Indep B ∧ ∀ ⦃y : Set α⦄, M.Indep y → B ⊆ y → B = y
hInotmax : ∃ x, M.Indep x ∧ I ⊆ x ∧ ¬I = x
hIb : M.Base I
⊢ False
state_after: case refine_1.intro.intro.intro
α : Type u_1
M✝ M : Matroid α
I B : Set α
hI : M.Indep I
hB : M.Indep B ∧ ∀ ⦃y : Set α⦄, M.Indep y → B ⊆ y → B = y
hIb : M.Base I
I' : Set α
hII' : M.Indep I'
hI' : I ⊆ I'
hne : ¬I = I'
⊢ False

tactic: exact hne <| hIb.eq_of_subset_indep hII' hI'
state_before: case refine_1.intro.intro.intro
α : Type u_1
M✝ M : Matroid α
I B : Set α
hI : M.Indep I
hB : M.Indep B ∧ ∀ ⦃y : Set α⦄, M.Indep y → B ⊆ y → B = y
hIb : M.Base I
I' : Set α
hII' : M.Indep I'
hI' : I ⊆ I'
hne : ¬I = I'
⊢ False
state_after: no goals
Theorem: PartialEquiv.refl_restr_source
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
s : Set α
⊢ ((PartialEquiv.refl α).restr s).source = s
state_after: no goals
Theorem: MvPolynomial.IsWeightedHomogeneous.inj_right
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

tactic: obtain ⟨d, hd⟩ : ∃ d, coeff d φ ≠ 0 := exists_coeff_ne_zero hφ
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
φ ψ : MvPolynomial σ R
m n : M
w : σ → M
hφ : φ ≠ 0
hm : IsWeightedHomogeneous w φ m
hn : IsWeightedHomogeneous w φ n
⊢ m = n
state_after: case intro
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
φ ψ : MvPolynomial σ R
m n : M
w : σ → M
hφ : φ ≠ 0
hm : IsWeightedHomogeneous w φ m
hn : IsWeightedHomogeneous w φ n
d : σ →₀ ℕ
hd : coeff d φ ≠ 0
⊢ m = n

tactic: rw [← hm hd, ← hn hd]
state_before: case intro
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
φ ψ : MvPolynomial σ R
m n : M
w : σ → M
hφ : φ ≠ 0
hm : IsWeightedHomogeneous w φ m
hn : IsWeightedHomogeneous w φ n
d : σ →₀ ℕ
hd : coeff d φ ≠ 0
⊢ m = n
state_after: no goals
Theorem: Nat.factorial_mul_ascFactorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [ascFactorial_zero, Nat.add_zero, Nat.mul_one]
state_before: n : ℕ
⊢ n ! * (n + 1).ascFactorial 0 = (n + 0)!
state_after: no goals

tactic: rw [ascFactorial_succ, ← Nat.add_assoc, factorial_succ, Nat.mul_comm (n + 1 + k),
  ← Nat.mul_assoc, factorial_mul_ascFactorial n k, Nat.mul_comm, Nat.add_right_comm]
state_before: n k : ℕ
⊢ n ! * (n + 1).ascFactorial (k + 1) = (n + (k + 1))!
state_after: no goals
Theorem: descPochhammer_succ_right
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: suffices h : descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - (n : ℤ[X])) by
  apply_fun Polynomial.map (algebraMap ℤ R) at h
  simpa [descPochhammer_map, Polynomial.map_mul, Polynomial.map_add, map_X,
    Polynomial.map_intCast] using h
state_before: R : Type u
inst✝ : Ring R
n : ℕ
⊢ descPochhammer R (n + 1) = descPochhammer R n * (X - ↑n)
state_after: R : Type u
inst✝ : Ring R
n : ℕ
⊢ descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - ↑n)

tactic: induction' n with n ih
state_before: R : Type u
inst✝ : Ring R
n : ℕ
⊢ descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - ↑n)
state_after: case zero
R : Type u
inst✝ : Ring R
⊢ descPochhammer ℤ (0 + 1) = descPochhammer ℤ 0 * (X - ↑0)

case succ
R : Type u
inst✝ : Ring R
n : ℕ
ih : descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - ↑n)
⊢ descPochhammer ℤ (n + 1 + 1) = descPochhammer ℤ (n + 1) * (X - ↑(n + 1))

tactic: apply_fun Polynomial.map (algebraMap ℤ R) at h
state_before: R : Type u
inst✝ : Ring R
n : ℕ
h : descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - ↑n)
⊢ descPochhammer R (n + 1) = descPochhammer R n * (X - ↑n)
state_after: R : Type u
inst✝ : Ring R
n : ℕ
h : map (algebraMap ℤ R) (descPochhammer ℤ (n + 1)) = map (algebraMap ℤ R) (descPochhammer ℤ n * (X - ↑n))
⊢ descPochhammer R (n + 1) = descPochhammer R n * (X - ↑n)

tactic: simpa [descPochhammer_map, Polynomial.map_mul, Polynomial.map_add, map_X,
  Polynomial.map_intCast] using h
state_before: R : Type u
inst✝ : Ring R
n : ℕ
h : map (algebraMap ℤ R) (descPochhammer ℤ (n + 1)) = map (algebraMap ℤ R) (descPochhammer ℤ n * (X - ↑n))
⊢ descPochhammer R (n + 1) = descPochhammer R n * (X - ↑n)
state_after: no goals

tactic: simp [descPochhammer]
state_before: case zero
R : Type u
inst✝ : Ring R
⊢ descPochhammer ℤ (0 + 1) = descPochhammer ℤ 0 * (X - ↑0)
state_after: no goals

tactic: conv_lhs =>
  rw [descPochhammer_succ_left, ih, mul_comp, ← mul_assoc, ← descPochhammer_succ_left, sub_comp,
      X_comp, natCast_comp]
state_before: case succ
R : Type u
inst✝ : Ring R
n : ℕ
ih : descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - ↑n)
⊢ descPochhammer ℤ (n + 1 + 1) = descPochhammer ℤ (n + 1) * (X - ↑(n + 1))
state_after: case succ
R : Type u
inst✝ : Ring R
n : ℕ
ih : descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - ↑n)
⊢ descPochhammer ℤ (n + 1) * (X - 1 - ↑n) = descPochhammer ℤ (n + 1) * (X - ↑(n + 1))

tactic: rw [Nat.cast_add, Nat.cast_one, sub_add_eq_sub_sub_swap]
state_before: case succ
R : Type u
inst✝ : Ring R
n : ℕ
ih : descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - ↑n)
⊢ descPochhammer ℤ (n + 1) * (X - 1 - ↑n) = descPochhammer ℤ (n + 1) * (X - ↑(n + 1))
state_after: no goals
Theorem: Matrix.exp_conj'
File: Mathlib/Analysis/NormedSpace/MatrixExponential.lean

tactic: simpa only [Matrix.coe_units_inv] using exp_units_conj' 𝕂 u A
state_before: 𝕂 : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
n' : m → Type u_5
𝔸 : Type u_6
inst✝⁹ : RCLike 𝕂
inst✝⁸ : Fintype m
inst✝⁷ : DecidableEq m
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : (i : m) → Fintype (n' i)
inst✝³ : (i : m) → DecidableEq (n' i)
inst✝² : NormedCommRing 𝔸
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : CompleteSpace 𝔸
U A : Matrix m m 𝔸
hy : IsUnit U
u : (Matrix m m 𝔸)ˣ
hu : ↑u = U
⊢ exp 𝕂 ((↑u)⁻¹ * A * ↑u) = (↑u)⁻¹ * exp 𝕂 A * ↑u
state_after: no goals
Theorem: Tropical.add_eq_right
File: Mathlib/Algebra/Tropical/Basic.lean

tactic: simpa using h
state_before: R : Type u
inst✝ : LinearOrder R
x y : Tropical R
h : y ≤ x
⊢ untrop (x + y) = untrop y
state_after: no goals
Theorem: Set.MapsTo.coe_iterate_restrict
File: Mathlib/Data/Set/Function.lean

tactic: induction' k with k ih
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
h : MapsTo f s s
x : ↑s
k : ℕ
⊢ ↑((restrict f s s h)^[k] x) = f^[k] ↑x
state_after: case zero
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
h : MapsTo f s s
x : ↑s
⊢ ↑((restrict f s s h)^[0] x) = f^[0] ↑x

case succ
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
h : MapsTo f s s
x : ↑s
k : ℕ
ih : ↑((restrict f s s h)^[k] x) = f^[k] ↑x
⊢ ↑((restrict f s s h)^[k + 1] x) = f^[k + 1] ↑x

tactic: simp only [iterate_succ', comp_apply, val_restrict_apply, ih]
state_before: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
h : MapsTo f s s
x : ↑s
k : ℕ
ih : ↑((restrict f s s h)^[k] x) = f^[k] ↑x
⊢ ↑((restrict f s s h)^[k + 1] x) = f^[k + 1] ↑x
state_after: no goals

tactic: simp
state_before: case zero
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
h : MapsTo f s s
x : ↑s
⊢ ↑((restrict f s s h)^[0] x) = f^[0] ↑x
state_after: no goals
Theorem: CategoryTheory.ComposableArrows.Precomp.map_one_succ
File: Mathlib/CategoryTheory/ComposableArrows.lean

tactic: simp [Fin.le_def]
state_before: C : Type u_1
inst✝ : Category.{?u.101325, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : C
f : X ⟶ F.left
j : ℕ
hj : j + 1 < n + 1 + 1
⊢ 1 ≤ ⟨j + 1, hj⟩
state_after: no goals
Theorem: TopologicalSpace.ext_iff
File: Mathlib/Topology/Basic.lean

tactic: ext
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
t t' : TopologicalSpace X
h : ∀ (s : Set X), IsOpen s ↔ IsOpen s
⊢ t = t'
state_after: case a.h.a
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
t t' : TopologicalSpace X
h : ∀ (s : Set X), IsOpen s ↔ IsOpen s
x✝ : Set X
⊢ IsOpen x✝ ↔ IsOpen x✝

tactic: exact h _
state_before: case a.h.a
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
t t' : TopologicalSpace X
h : ∀ (s : Set X), IsOpen s ↔ IsOpen s
x✝ : Set X
⊢ IsOpen x✝ ↔ IsOpen x✝
state_after: no goals
Theorem: Ordinal.sub_eq_zero_iff_le
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [h, add_zero] using le_add_sub a b
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
h : a - b = 0
⊢ a ≤ b
state_after: no goals

tactic: rwa [← Ordinal.le_zero, sub_le, add_zero]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
h : a ≤ b
⊢ a - b = 0
state_after: no goals
Theorem: eq_zero_of_zero_eq_one
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [← mul_one a, ← h, mul_zero]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MulZeroOneClass M₀
h : 0 = 1
a : M₀
⊢ a = 0
state_after: no goals
Theorem: PrimeSpectrum.basicOpen_le_basicOpen_iff
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [← SetLike.coe_subset_coe, basicOpen_eq_zeroLocus_compl, basicOpen_eq_zeroLocus_compl,
  Set.compl_subset_compl, zeroLocus_subset_zeroLocus_singleton_iff]
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f g : R
⊢ basicOpen f ≤ basicOpen g ↔ f ∈ (Ideal.span {g}).radical
state_after: no goals
Theorem: MvPolynomial.eval₂_comp_left
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: apply MvPolynomial.induction_on p <;>
  simp (config := { contextual := true }) [eval₂_add, k.map_add, eval₂_mul, k.map_mul]
state_before: R : Type u
S₁ : Type v
S₂✝ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : R →+* S₁
g✝ : σ → S₁
S₂ : Type u_2
inst✝ : CommSemiring S₂
k : S₁ →+* S₂
f : R →+* S₁
g : σ → S₁
p : MvPolynomial σ R
⊢ k (eval₂ f g p) = eval₂ (k.comp f) (⇑k ∘ g) p
state_after: no goals