1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MvPolynomial.eval₂_eq'
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: simp only [eval₂_eq, ← Finsupp.prod_pow]
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₁
inst✝ : Fintype σ
g : R →+* S₁
X : σ → S₁
f : MvPolynomial σ R
⊢ eval₂ g X f = ∑ d ∈ f.support, g (coeff d f) * ∏ i : σ, X i ^ d i
state_after: 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₁
inst✝ : Fintype σ
g : R →+* S₁
X : σ → S₁
f : MvPolynomial σ R
⊢ ∑ d ∈ f.support, g (coeff d f) * ∏ i ∈ d.support, X i ^ d i =
    ∑ x ∈ f.support, g (coeff x f) * x.prod fun a b => X a ^ b

tactic: rfl
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₁
inst✝ : Fintype σ
g : R →+* S₁
X : σ → S₁
f : MvPolynomial σ R
⊢ ∑ d ∈ f.support, g (coeff d f) * ∏ i ∈ d.support, X i ^ d i =
    ∑ x ∈ f.support, g (coeff x f) * x.prod fun a b => X a ^ b
state_after: no goals
Theorem: ENNReal.coe_mem_upperBounds
File: Mathlib/Data/ENNReal/Basic.lean

tactic: simp (config := { contextual := true }) [upperBounds, forall_mem_image, -mem_image, *]
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort u_2
f : ι → ℝ≥0
s : Set ℝ≥0
⊢ ↑r ∈ upperBounds (ofNNReal '' s) ↔ r ∈ upperBounds s
state_after: no goals
Theorem: PrimeSpectrum.mem_compl_zeroLocus_iff_not_mem
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [Set.mem_compl_iff, mem_zeroLocus, Set.singleton_subset_iff]
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R
I : PrimeSpectrum R
⊢ I ∈ (zeroLocus {f})ᶜ ↔ f ∉ I.asIdeal
state_after: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R
I : PrimeSpectrum R
⊢ f ∉ ↑I.asIdeal ↔ f ∉ I.asIdeal

tactic: rfl
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R
I : PrimeSpectrum R
⊢ f ∉ ↑I.asIdeal ↔ f ∉ I.asIdeal
state_after: no goals
Theorem: Nat.pow_lt_pow_left
File: Mathlib/Data/Nat/Defs.lean

tactic: simpa
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : a < b
x✝ : 1 ≠ 0
⊢ a ^ 1 < b ^ 1
state_after: no goals
Theorem: List.Perm.union_left
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

tactic: induction l with
| nil => simp only [nil_union, h]
| cons _ _ ih => simp only [cons_union, Perm.insert _ ih]
state_before: α : Type u_1
inst✝ : DecidableEq α
l t₁ t₂ : List α
h : t₁ ~ t₂
⊢ l ∪ t₁ ~ l ∪ t₂
state_after: no goals

tactic: simp only [nil_union, h]
state_before: case nil
α : Type u_1
inst✝ : DecidableEq α
t₁ t₂ : List α
h : t₁ ~ t₂
⊢ [] ∪ t₁ ~ [] ∪ t₂
state_after: no goals

tactic: simp only [cons_union, Perm.insert _ ih]
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
t₁ t₂ : List α
h : t₁ ~ t₂
head✝ : α
tail✝ : List α
ih : tail✝ ∪ t₁ ~ tail✝ ∪ t₂
⊢ head✝ :: tail✝ ∪ t₁ ~ head✝ :: tail✝ ∪ t₂
state_after: no goals
Theorem: Equiv.equivCongr_symm
File: Mathlib/Logic/Equiv/Defs.lean

tactic: ext
state_before: α : Sort u
β : Sort v
γ : Sort w
δ : Sort u_1
ab : α ≃ β
cd : γ ≃ δ
⊢ (ab.equivCongr cd).symm = ab.symm.equivCongr cd.symm
state_after: case H.H
α : Sort u
β : Sort v
γ : Sort w
δ : Sort u_1
ab : α ≃ β
cd : γ ≃ δ
x✝¹ : β ≃ δ
x✝ : α
⊢ ((ab.equivCongr cd).symm x✝¹) x✝ = ((ab.symm.equivCongr cd.symm) x✝¹) x✝

tactic: rfl
state_before: case H.H
α : Sort u
β : Sort v
γ : Sort w
δ : Sort u_1
ab : α ≃ β
cd : γ ≃ δ
x✝¹ : β ≃ δ
x✝ : α
⊢ ((ab.equivCongr cd).symm x✝¹) x✝ = ((ab.symm.equivCongr cd.symm) x✝¹) x✝
state_after: no goals
Theorem: CochainComplex.single₀_map_f_zero
File: Mathlib/Algebra/Homology/Single.lean

tactic: rw [HomologicalComplex.single_map_f_self]
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
A B : V
f : A ⟶ B
⊢ ((single₀ V).map f).f 0 = f
state_after: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
A B : V
f : A ⟶ B
⊢ (HomologicalComplex.singleObjXSelf (ComplexShape.up ℕ) 0 A).hom ≫
      f ≫ (HomologicalComplex.singleObjXSelf (ComplexShape.up ℕ) 0 B).inv =
    f

tactic: dsimp [HomologicalComplex.singleObjXSelf, HomologicalComplex.singleObjXIsoOfEq]
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
A B : V
f : A ⟶ B
⊢ (HomologicalComplex.singleObjXSelf (ComplexShape.up ℕ) 0 A).hom ≫
      f ≫ (HomologicalComplex.singleObjXSelf (ComplexShape.up ℕ) 0 B).inv =
    f
state_after: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
A B : V
f : A ⟶ B
⊢ 𝟙 A ≫ f ≫ 𝟙 B = f

tactic: erw [comp_id, id_comp]
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
A B : V
f : A ⟶ B
⊢ 𝟙 A ≫ f ≫ 𝟙 B = f
state_after: no goals
Theorem: Computation.rel_of_liftRel
File: Mathlib/Data/Seq/Computation.lean

tactic: let ⟨b', mb', ab'⟩ := l ma
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
l : ∀ {a : α}, a ∈ ca → ∃ b, b ∈ cb ∧ R a b
right✝ : ∀ {b : β}, b ∈ cb → ∃ a, a ∈ ca ∧ R a b
a : α
b : β
ma : a ∈ ca
mb : b ∈ cb
⊢ R a b
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
l : ∀ {a : α}, a ∈ ca → ∃ b, b ∈ cb ∧ R a b
right✝ : ∀ {b : β}, b ∈ cb → ∃ a, a ∈ ca ∧ R a b
a : α
b : β
ma : a ∈ ca
mb : b ∈ cb
b' : β
mb' : b' ∈ cb
ab' : R a b'
⊢ R a b

tactic: rw [mem_unique mb mb']
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
l : ∀ {a : α}, a ∈ ca → ∃ b, b ∈ cb ∧ R a b
right✝ : ∀ {b : β}, b ∈ cb → ∃ a, a ∈ ca ∧ R a b
a : α
b : β
ma : a ∈ ca
mb : b ∈ cb
b' : β
mb' : b' ∈ cb
ab' : R a b'
⊢ R a b
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
l : ∀ {a : α}, a ∈ ca → ∃ b, b ∈ cb ∧ R a b
right✝ : ∀ {b : β}, b ∈ cb → ∃ a, a ∈ ca ∧ R a b
a : α
b : β
ma : a ∈ ca
mb : b ∈ cb
b' : β
mb' : b' ∈ cb
ab' : R a b'
⊢ R a b'

tactic: exact ab'
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
l : ∀ {a : α}, a ∈ ca → ∃ b, b ∈ cb ∧ R a b
right✝ : ∀ {b : β}, b ∈ cb → ∃ a, a ∈ ca ∧ R a b
a : α
b : β
ma : a ∈ ca
mb : b ∈ cb
b' : β
mb' : b' ∈ cb
ab' : R a b'
⊢ R a b'
state_after: no goals
Theorem: continuous_mulIndicator
File: Mathlib/Topology/ContinuousOn.lean

tactic: classical exact continuous_piecewise hs hf continuousOn_const
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 δ
inst✝ : One β
f : α → β
s : Set α
hs : ∀ a ∈ frontier s, f a = 1
hf : ContinuousOn f (closure s)
⊢ Continuous (s.mulIndicator f)
state_after: no goals

tactic: exact continuous_piecewise hs hf continuousOn_const
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 δ
inst✝ : One β
f : α → β
s : Set α
hs : ∀ a ∈ frontier s, f a = 1
hf : ContinuousOn f (closure s)
⊢ Continuous (s.mulIndicator f)
state_after: no goals
Theorem: Multiset.mem_singleton
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp only [← cons_zero, mem_cons, iff_self_iff, or_false_iff, not_mem_zero]
state_before: α : Type u_1
β : Type v
γ : Type u_2
a b : α
⊢ b ∈ {a} ↔ b = a
state_after: no goals
Theorem: Num.cast_bit1
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← bit1_of_bit1, _root_.bit1, bit0_of_bit0, cast_add, cast_bit0]
state_before: α : Type u_1
inst✝ : Semiring α
n : Num
⊢ ↑n.bit1 = _root_.bit1 ↑n
state_after: α : Type u_1
inst✝ : Semiring α
n : Num
⊢ _root_.bit0 ↑n + ↑1 = _root_.bit1 ↑n

tactic: rfl
state_before: α : Type u_1
inst✝ : Semiring α
n : Num
⊢ _root_.bit0 ↑n + ↑1 = _root_.bit1 ↑n
state_after: no goals
Theorem: CategoryTheory.GrothendieckTopology.plusMap_plusLift
File: Mathlib/CategoryTheory/Sites/Plus.lean

tactic: apply J.plusLift_unique
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ J.plusMap η ≫ J.plusLift γ hR = J.plusLift (η ≫ γ) hR
state_after: case hγ
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ J.toPlus P ≫ J.plusMap η ≫ J.plusLift γ hR = η ≫ γ

tactic: rw [← Category.assoc, ← J.toPlus_naturality, Category.assoc, J.toPlus_plusLift]
state_before: case hγ
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P✝ : Cᵒᵖ ⥤ D
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ J.toPlus P ≫ J.plusMap η ≫ J.plusLift γ hR = η ≫ γ
state_after: no goals
Theorem: intervalIntegral.inv_smul_integral_comp_div
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: by_cases hc : c = 0 <;> simp [hc, integral_comp_div]
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 c✝ d : ℝ
f : ℝ → E
c : ℝ
⊢ c⁻¹ • ∫ (x : ℝ) in a..b, f (x / c) = ∫ (x : ℝ) in a / c..b / c, f x
state_after: no goals
Theorem: Nat.card_eq
File: Mathlib/Data/Finite/Card.lean

tactic: cases finite_or_infinite α
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
⊢ Nat.card α = if h : Finite α then Fintype.card α else 0
state_after: case inl
α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
h✝ : Finite α
⊢ Nat.card α = if h : Finite α then Fintype.card α else 0

case inr
α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
h✝ : Infinite α
⊢ Nat.card α = if h : Finite α then Fintype.card α else 0

tactic: letI := Fintype.ofFinite α
state_before: case inl
α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
h✝ : Finite α
⊢ Nat.card α = if h : Finite α then Fintype.card α else 0
state_after: case inl
α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
h✝ : Finite α
this : Fintype α := Fintype.ofFinite α
⊢ Nat.card α = if h : Finite α then Fintype.card α else 0

tactic: simp only [*, Nat.card_eq_fintype_card, dif_pos]
state_before: case inl
α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
h✝ : Finite α
this : Fintype α := Fintype.ofFinite α
⊢ Nat.card α = if h : Finite α then Fintype.card α else 0
state_after: no goals

tactic: simp only [*, card_eq_zero_of_infinite, not_finite_iff_infinite.mpr, dite_false]
state_before: case inr
α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
h✝ : Infinite α
⊢ Nat.card α = if h : Finite α then Fintype.card α else 0
state_after: no goals
Theorem: Set.InjOn.image_diff
File: Mathlib/Data/Set/Function.lean

tactic: refine subset_antisymm (subset_diff.2 ⟨image_subset f diff_subset, ?_⟩)
  (diff_subset_iff.2 (by rw [← image_union, inter_union_diff]))
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 : β
t : Set α
h : InjOn f s
⊢ f '' (s \ t) = f '' s \ f '' (s ∩ t)
state_after: α : 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 : β
t : Set α
h : InjOn f s
⊢ Disjoint (f '' (s \ t)) (f '' (s ∩ t))

tactic: exact Disjoint.image disjoint_sdiff_inter h diff_subset inter_subset_left
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 : β
t : Set α
h : InjOn f s
⊢ Disjoint (f '' (s \ t)) (f '' (s ∩ t))
state_after: no goals

tactic: rw [← image_union, inter_union_diff]
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 : β
t : Set α
h : InjOn f s
⊢ f '' s ⊆ f '' (s ∩ t) ∪ f '' (s \ t)
state_after: no goals
Theorem: OrderMonoidHom.toMonoidHom_injective
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: convert DFunLike.ext_iff.1 h using 0
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : MulOneClass γ
inst✝ : MulOneClass δ
f✝ g✝ f g : α →*o β
h : f.toMonoidHom = g.toMonoidHom
⊢ ∀ (a : α), f a = g a
state_after: no goals
Theorem: Orientation.inner_rev_eq_zero_of_oangle_eq_neg_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

tactic: rw [real_inner_comm, o.inner_eq_zero_of_oangle_eq_neg_pi_div_two h]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(-π / 2)
⊢ ⟪y, x⟫_ℝ = 0
state_after: no goals
Theorem: Ordinal.one_add_natCast
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← Nat.cast_one, ← Nat.cast_add, add_comm]
state_before: m : ℕ
⊢ 1 + ↑m = ↑(succ m)
state_after: m : ℕ
⊢ ↑(m + 1) = ↑(succ m)

tactic: rfl
state_before: m : ℕ
⊢ ↑(m + 1) = ↑(succ m)
state_after: no goals
Theorem: LowerAdjoint.closure_union_closure
File: Mathlib/Order/Closure.lean

tactic: rw [closure_union_closure_right, closure_union_closure_left]
state_before: α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
β : Type u_4
inst✝ : SetLike α β
l : LowerAdjoint SetLike.coe
x y : α
⊢ l.toFun (↑(l.toFun ↑x) ∪ ↑(l.toFun ↑y)) = l.toFun (↑x ∪ ↑y)
state_after: no goals
Theorem: Cubic.card_roots_of_disc_ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [toFinset_card_of_nodup <| (disc_ne_zero_iff_roots_nodup ha h3).mp hd,
  ← splits_iff_card_roots ha, splits_iff_roots_eq_three ha]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝² : Field F
inst✝¹ : Field K
φ : F →+* K
x y z : K
inst✝ : DecidableEq K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
hd : P.disc ≠ 0
⊢ (map φ P).roots.toFinset.card = 3
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝² : Field F
inst✝¹ : Field K
φ : F →+* K
x y z : K
inst✝ : DecidableEq K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
hd : P.disc ≠ 0
⊢ ∃ x y z, (map φ P).roots = {x, y, z}

tactic: exact ⟨x, ⟨y, ⟨z, h3⟩⟩⟩
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝² : Field F
inst✝¹ : Field K
φ : F →+* K
x y z : K
inst✝ : DecidableEq K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
hd : P.disc ≠ 0
⊢ ∃ x y z, (map φ P).roots = {x, y, z}
state_after: no goals
Theorem: Set.ext_iff
File: Mathlib/Data/Set/Basic.lean

tactic: rw [h]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
h : s = t
x : α
⊢ x ∈ s ↔ x ∈ t
state_after: no goals
Theorem: Set.OrdConnected.null_frontier
File: Mathlib/MeasureTheory/Order/UpperLower.lean

tactic: rw [← hs.upperClosure_inter_lowerClosure]
state_before: ι : Type u_1
inst✝ : Fintype ι
s : Set (ι → ℝ)
x y : ι → ℝ
δ : ℝ
hs : s.OrdConnected
⊢ volume (frontier s) = 0
state_after: ι : Type u_1
inst✝ : Fintype ι
s : Set (ι → ℝ)
x y : ι → ℝ
δ : ℝ
hs : s.OrdConnected
⊢ volume (frontier (↑(upperClosure s) ∩ ↑(lowerClosure s))) = 0

tactic: exact measure_mono_null (frontier_inter_subset _ _) $ measure_union_null
  (measure_inter_null_of_null_left _ (UpperSet.upper _).null_frontier)
  (measure_inter_null_of_null_right _ (LowerSet.lower _).null_frontier)
state_before: ι : Type u_1
inst✝ : Fintype ι
s : Set (ι → ℝ)
x y : ι → ℝ
δ : ℝ
hs : s.OrdConnected
⊢ volume (frontier (↑(upperClosure s) ∩ ↑(lowerClosure s))) = 0
state_after: no goals
Theorem: Vector.mapAccumr_eq_map
File: Mathlib/Data/Vector/MapLemmas.lean

tactic: rw [Vector.map_eq_mapAccumr]
state_before: α : Type u_2
n : ℕ
β : Type u_1
xs : Vector α n
ys : Vector β n
σ : Type
f : α → σ → σ × β
s₀ : σ
S : Set σ
h₀ : s₀ ∈ S
closure : ∀ (a : α), ∀ s ∈ S, (f a s).1 ∈ S
out : ∀ (a : α) (s s' : σ), s ∈ S → s' ∈ S → (f a s).2 = (f a s').2
⊢ (mapAccumr f xs s₀).2 = map (fun x => (f x s₀).2) xs
state_after: α : Type u_2
n : ℕ
β : Type u_1
xs : Vector α n
ys : Vector β n
σ : Type
f : α → σ → σ × β
s₀ : σ
S : Set σ
h₀ : s₀ ∈ S
closure : ∀ (a : α), ∀ s ∈ S, (f a s).1 ∈ S
out : ∀ (a : α) (s s' : σ), s ∈ S → s' ∈ S → (f a s).2 = (f a s').2
⊢ (mapAccumr f xs s₀).2 = (mapAccumr (fun x x_1 => ((), (f x s₀).2)) xs ()).2

tactic: apply mapAccumr_bisim_tail
state_before: α : Type u_2
n : ℕ
β : Type u_1
xs : Vector α n
ys : Vector β n
σ : Type
f : α → σ → σ × β
s₀ : σ
S : Set σ
h₀ : s₀ ∈ S
closure : ∀ (a : α), ∀ s ∈ S, (f a s).1 ∈ S
out : ∀ (a : α) (s s' : σ), s ∈ S → s' ∈ S → (f a s).2 = (f a s').2
⊢ (mapAccumr f xs s₀).2 = (mapAccumr (fun x x_1 => ((), (f x s₀).2)) xs ()).2
state_after: case h
α : Type u_2
n : ℕ
β : Type u_1
xs : Vector α n
ys : Vector β n
σ : Type
f : α → σ → σ × β
s₀ : σ
S : Set σ
h₀ : s₀ ∈ S
closure : ∀ (a : α), ∀ s ∈ S, (f a s).1 ∈ S
out : ∀ (a : α) (s s' : σ), s ∈ S → s' ∈ S → (f a s).2 = (f a s').2
⊢ ∃ R, R s₀ () ∧ ∀ {s : σ} {q : Unit} (a : α), R s q → R (f a s).1 ((), (f a s₀).2).1 ∧ (f a s).2 = ((), (f a s₀).2).2

tactic: use fun s _ => s ∈ S, h₀
state_before: case h
α : Type u_2
n : ℕ
β : Type u_1
xs : Vector α n
ys : Vector β n
σ : Type
f : α → σ → σ × β
s₀ : σ
S : Set σ
h₀ : s₀ ∈ S
closure : ∀ (a : α), ∀ s ∈ S, (f a s).1 ∈ S
out : ∀ (a : α) (s s' : σ), s ∈ S → s' ∈ S → (f a s).2 = (f a s').2
⊢ ∃ R, R s₀ () ∧ ∀ {s : σ} {q : Unit} (a : α), R s q → R (f a s).1 ((), (f a s₀).2).1 ∧ (f a s).2 = ((), (f a s₀).2).2
state_after: case right
α : Type u_2
n : ℕ
β : Type u_1
xs : Vector α n
ys : Vector β n
σ : Type
f : α → σ → σ × β
s₀ : σ
S : Set σ
h₀ : s₀ ∈ S
closure : ∀ (a : α), ∀ s ∈ S, (f a s).1 ∈ S
out : ∀ (a : α) (s s' : σ), s ∈ S → s' ∈ S → (f a s).2 = (f a s').2
⊢ ∀ {s : σ} {q : Unit} (a : α), s ∈ S → (f a s).1 ∈ S ∧ (f a s).2 = ((), (f a s₀).2).2

tactic: exact @fun s _q a h => ⟨closure a s h, out a s s₀ h h₀⟩
state_before: case right
α : Type u_2
n : ℕ
β : Type u_1
xs : Vector α n
ys : Vector β n
σ : Type
f : α → σ → σ × β
s₀ : σ
S : Set σ
h₀ : s₀ ∈ S
closure : ∀ (a : α), ∀ s ∈ S, (f a s).1 ∈ S
out : ∀ (a : α) (s s' : σ), s ∈ S → s' ∈ S → (f a s).2 = (f a s').2
⊢ ∀ {s : σ} {q : Unit} (a : α), s ∈ S → (f a s).1 ∈ S ∧ (f a s).2 = ((), (f a s₀).2).2
state_after: no goals
Theorem: CategoryTheory.Adjunction.homEquiv_symm_rightAdjointUniq_hom_app
File: Mathlib/CategoryTheory/Adjunction/Unique.lean

tactic: simp [rightAdjointUniq]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
⊢ (adj2.homEquiv (G.obj x) x).symm ((adj1.rightAdjointUniq adj2).hom.app x) = adj1.counit.app x
state_after: no goals
Theorem: Stirling.stirlingSeq'_pos
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

tactic: unfold stirlingSeq
state_before: n : ℕ
⊢ 0 < stirlingSeq (n + 1)
state_after: n : ℕ
⊢ 0 < ↑(n + 1)! / (√(2 * ↑(n + 1)) * (↑(n + 1) / rexp 1) ^ (n + 1))

tactic: positivity
state_before: n : ℕ
⊢ 0 < ↑(n + 1)! / (√(2 * ↑(n + 1)) * (↑(n + 1) / rexp 1) ^ (n + 1))
state_after: no goals
Theorem: List.length_eraseIdx
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp [eraseIdx]
state_before: α : Type u_1
head✝ : α
tail✝ : List α
x✝ : 0 < (head✝ :: tail✝).length
⊢ ((head✝ :: tail✝).eraseIdx 0).length = (head✝ :: tail✝).length - 1
state_after: no goals

tactic: have : i < length xs := Nat.lt_of_succ_lt_succ h
state_before: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < (x :: xs).length
⊢ ((x :: xs).eraseIdx (i + 1)).length = (x :: xs).length - 1
state_after: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < (x :: xs).length
this : i < xs.length
⊢ ((x :: xs).eraseIdx (i + 1)).length = (x :: xs).length - 1

tactic: simp [eraseIdx, ← Nat.add_one]
state_before: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < (x :: xs).length
this : i < xs.length
⊢ ((x :: xs).eraseIdx (i + 1)).length = (x :: xs).length - 1
state_after: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < (x :: xs).length
this : i < xs.length
⊢ (xs.eraseIdx i).length + 1 = xs.length

tactic: rw [length_eraseIdx this, Nat.sub_add_cancel (Nat.lt_of_le_of_lt (Nat.zero_le _) this)]
state_before: α : Type u_1
x : α
xs : List α
i : Nat
h : i + 1 < (x :: xs).length
this : i < xs.length
⊢ (xs.eraseIdx i).length + 1 = xs.length
state_after: no goals
Theorem: div_pos_iff_of_pos_right
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simp only [div_eq_mul_inv, mul_pos_iff_of_pos_right (inv_pos.2 hb)]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hb : 0 < b
⊢ 0 < a / b ↔ 0 < a
state_after: no goals
Theorem: Polynomial.cyclotomic'_one
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: simp only [cyclotomic', Finset.prod_singleton, RingHom.map_one,
  IsPrimitiveRoot.primitiveRoots_one]
state_before: R✝ : Type u_1
inst✝³ : CommRing R✝
inst✝² : IsDomain R✝
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ cyclotomic' 1 R = X - 1
state_after: no goals
Theorem: iSup_false
File: Mathlib/Order/CompleteLattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f g s✝ t : ι → α
a b : α
s : False → α
⊢ iSup s = ⊥
state_after: no goals
Theorem: CategoryTheory.ShortComplex.SnakeInput.L₀X₂ToP_comp_φ₁
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

tactic: simp only [← cancel_mono S.L₂.f, L₀X₂ToP, assoc, φ₂, φ₁_L₂_f,
  pullback.lift_fst_assoc, w₀₂_τ₂, zero_comp]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ S.L₀X₂ToP ≫ S.φ₁ = 0
state_after: no goals
Theorem: AffineSubspace.wSameSide_vadd_right_iff
File: Mathlib/Analysis/Convex/Side.lean

tactic: rw [wSameSide_comm, wSameSide_vadd_left_iff hv, wSameSide_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
v : V
hv : v ∈ s.direction
⊢ s.WSameSide x (v +ᵥ y) ↔ s.WSameSide x y
state_after: no goals
Theorem: csSup_Iio
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: simpa [and_comm] using exists_between hw
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝² : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝¹ : NoMinOrder α
inst✝ : DenselyOrdered α
w : α
hw : w < a
⊢ ∃ a_1 ∈ Iio a, w < a_1
state_after: no goals
Theorem: Real.rpow_one_add'
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_add' hx h, rpow_one]
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
h : 1 + y ≠ 0
⊢ x ^ (1 + y) = x * x ^ y
state_after: no goals