1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: two_mul_card_alternatingGroup
File: Mathlib/GroupTheory/SpecificGroups/Alternating.lean

tactic: let this := (QuotientGroup.quotientKerEquivOfSurjective _ (sign_surjective α)).toEquiv
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
⊢ 2 * card ↥(alternatingGroup α) = card (Perm α)
state_after: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
this : Perm α ⧸ sign.ker ≃ ℤˣ := (QuotientGroup.quotientKerEquivOfSurjective sign ⋯).toEquiv
⊢ 2 * card ↥(alternatingGroup α) = card (Perm α)

tactic: rw [← Fintype.card_units_int, ← Fintype.card_congr this]
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
this : Perm α ⧸ sign.ker ≃ ℤˣ := (QuotientGroup.quotientKerEquivOfSurjective sign ⋯).toEquiv
⊢ 2 * card ↥(alternatingGroup α) = card (Perm α)
state_after: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
this : Perm α ⧸ sign.ker ≃ ℤˣ := (QuotientGroup.quotientKerEquivOfSurjective sign ⋯).toEquiv
⊢ card (Perm α ⧸ sign.ker) * card ↥(alternatingGroup α) = card (Perm α)

tactic: simp only [← Nat.card_eq_fintype_card]
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
this : Perm α ⧸ sign.ker ≃ ℤˣ := (QuotientGroup.quotientKerEquivOfSurjective sign ⋯).toEquiv
⊢ card (Perm α ⧸ sign.ker) * card ↥(alternatingGroup α) = card (Perm α)
state_after: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
this : Perm α ⧸ sign.ker ≃ ℤˣ := (QuotientGroup.quotientKerEquivOfSurjective sign ⋯).toEquiv
⊢ Nat.card (Perm α ⧸ sign.ker) * Nat.card ↥(alternatingGroup α) = Nat.card (Perm α)

tactic: apply (Subgroup.card_eq_card_quotient_mul_card_subgroup _).symm
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nontrivial α
this : Perm α ⧸ sign.ker ≃ ℤˣ := (QuotientGroup.quotientKerEquivOfSurjective sign ⋯).toEquiv
⊢ Nat.card (Perm α ⧸ sign.ker) * Nat.card ↥(alternatingGroup α) = Nat.card (Perm α)
state_after: no goals
Theorem: List.rtakeWhile_concat
File: Mathlib/Data/List/DropRight.lean

tactic: simp only [rtakeWhile, takeWhile, reverse_append, reverse_singleton, singleton_append]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ rtakeWhile p (l ++ [x]) = if p x = true then rtakeWhile p l ++ [x] else []
state_after: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ (match p x with
      | true => x :: takeWhile p l.reverse
      | false => []).reverse =
    if p x = true then (takeWhile p l.reverse).reverse ++ [x] else []

tactic: split_ifs with h <;> simp [h]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ (match p x with
      | true => x :: takeWhile p l.reverse
      | false => []).reverse =
    if p x = true then (takeWhile p l.reverse).reverse ++ [x] else []
state_after: no goals
Theorem: Equiv.comp_traverse
File: Mathlib/Control/Traversable/Equiv.lean

tactic: rw [traverse_def, comp_traverse, Comp.map_mk]
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : β → F γ
g : α → G β
x : t' α
⊢ Equiv.traverse eqv (Comp.mk ∘ map f ∘ g) x = Comp.mk (Equiv.traverse eqv f <$> Equiv.traverse eqv g x)
state_after: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : β → F γ
g : α → G β
x : t' α
⊢ Comp.mk ((fun x => ⇑(eqv γ) <$> x) <$> traverse f <$> traverse g ((eqv α).symm x)) =
    Comp.mk (Equiv.traverse eqv f <$> Equiv.traverse eqv g x)

tactic: simp only [map_map, Function.comp_def, traverse_def, symm_apply_apply]
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : β → F γ
g : α → G β
x : t' α
⊢ Comp.mk ((fun x => ⇑(eqv γ) <$> x) <$> traverse f <$> traverse g ((eqv α).symm x)) =
    Comp.mk (Equiv.traverse eqv f <$> Equiv.traverse eqv g x)
state_after: no goals
Theorem: AlgebraicGeometry.SheafedSpace.IsOpenImmersion.to_iso
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

tactic: haveI : IsIso (forgetToPresheafedSpace.map f) := PresheafedSpace.IsOpenImmersion.to_iso f
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : SheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
⊢ IsIso f
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : SheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
this : IsIso (forgetToPresheafedSpace.map f)
⊢ IsIso f

tactic: apply isIso_of_reflects_iso _ (SheafedSpace.forgetToPresheafedSpace)
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : SheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
this : IsIso (forgetToPresheafedSpace.map f)
⊢ IsIso f
state_after: no goals
Theorem: Fin.succAbove_ne
File: Mathlib/Data/Fin/Basic.lean

tactic: rcases p.castSucc_lt_or_lt_succ i with (h | h)
state_before: n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
⊢ p.succAbove i ≠ p
state_after: case inl
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
h : i.castSucc < p
⊢ p.succAbove i ≠ p

case inr
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
h : p < i.succ
⊢ p.succAbove i ≠ p

tactic: rw [succAbove_of_castSucc_lt _ _ h]
state_before: case inl
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
h : i.castSucc < p
⊢ p.succAbove i ≠ p
state_after: case inl
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
h : i.castSucc < p
⊢ i.castSucc ≠ p

tactic: exact Fin.ne_of_lt h
state_before: case inl
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
h : i.castSucc < p
⊢ i.castSucc ≠ p
state_after: no goals

tactic: rw [succAbove_of_lt_succ _ _ h]
state_before: case inr
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
h : p < i.succ
⊢ p.succAbove i ≠ p
state_after: case inr
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
h : p < i.succ
⊢ i.succ ≠ p

tactic: exact Fin.ne_of_gt h
state_before: case inr
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
h : p < i.succ
⊢ i.succ ≠ p
state_after: no goals
Theorem: SimpleGraph.edgeFinset_deleteEdges
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

tactic: ext e
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝² : DecidableEq V
inst✝¹ : Fintype ↑G.edgeSet
s : Finset (Sym2 V)
inst✝ : Fintype ↑(G.deleteEdges ↑s).edgeSet
⊢ (G.deleteEdges ↑s).edgeFinset = G.edgeFinset \ s
state_after: case a
V : Type u_1
G : SimpleGraph V
e✝ : Sym2 V
inst✝² : DecidableEq V
inst✝¹ : Fintype ↑G.edgeSet
s : Finset (Sym2 V)
inst✝ : Fintype ↑(G.deleteEdges ↑s).edgeSet
e : Sym2 V
⊢ e ∈ (G.deleteEdges ↑s).edgeFinset ↔ e ∈ G.edgeFinset \ s

tactic: simp [edgeSet_deleteEdges]
state_before: case a
V : Type u_1
G : SimpleGraph V
e✝ : Sym2 V
inst✝² : DecidableEq V
inst✝¹ : Fintype ↑G.edgeSet
s : Finset (Sym2 V)
inst✝ : Fintype ↑(G.deleteEdges ↑s).edgeSet
e : Sym2 V
⊢ e ∈ (G.deleteEdges ↑s).edgeFinset ↔ e ∈ G.edgeFinset \ s
state_after: no goals
Theorem: lineDerivWithin_congr
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

tactic: simpa using hx
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
f f₁ : E → F
f' f₀' f₁' : F
s t : Set E
x v : E
hs : EqOn f₁ f s
hx : f₁ x = f x
⊢ f₁ (x + 0 • v) = f (x + 0 • v)
state_after: no goals
Theorem: Valuation.IsEquiv.of_eq
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: subst h
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝⁴ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v v₁ : Valuation R Γ₀
v₂ : Valuation R Γ'₀
v₃ : Valuation R Γ''₀
v' : Valuation R Γ₀
h : v = v'
⊢ v.IsEquiv v'
state_after: K : Type u_1
F : Type u_2
R : Type u_3
inst✝⁴ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v v₁ : Valuation R Γ₀
v₂ : Valuation R Γ'₀
v₃ : Valuation R Γ''₀
⊢ v.IsEquiv v

tactic: rfl
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝⁴ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v v₁ : Valuation R Γ₀
v₂ : Valuation R Γ'₀
v₃ : Valuation R Γ''₀
⊢ v.IsEquiv v
state_after: no goals
Theorem: Real.dist_left_le_of_mem_uIcc
File: Mathlib/Topology/MetricSpace/Pseudo/Lemmas.lean

tactic: simpa only [dist_comm x] using abs_sub_left_of_mem_uIcc h
state_before: ι : Type u_1
α : Type u_2
inst✝ : PseudoMetricSpace α
x y z : ℝ
h : y ∈ uIcc x z
⊢ dist x y ≤ dist x z
state_after: no goals
Theorem: TrivSqZeroExt.inv_zero
File: Mathlib/Algebra/TrivSqZeroExt.lean

tactic: rw [← inl_zero, TrivSqZeroExt.inv_inl, inv_zero]
state_before: R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
⊢ 0⁻¹ = 0
state_after: no goals
Theorem: nhds_top_order
File: Mathlib/Topology/Order/Basic.lean

tactic: simp [nhds_eq_order (⊤ : α)]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : Preorder α
inst✝¹ : OrderTop α
inst✝ : OrderTopology α
⊢ 𝓝 ⊤ = ⨅ l, ⨅ (_ : l < ⊤), 𝓟 (Ioi l)
state_after: no goals
Theorem: Ordinal.nat_le_card
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [← Cardinal.ord_le, Cardinal.ord_nat]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
n : ℕ
⊢ ↑n ≤ o.card ↔ ↑n ≤ o
state_after: no goals
Theorem: Finset.disjSups_left_comm
File: Mathlib/Data/Finset/Sups.lean

tactic: simp_rw [← disjSups_assoc, disjSups_comm s]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq β
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s t u v : Finset α
⊢ s ○ (t ○ u) = t ○ (s ○ u)
state_after: no goals
Theorem: GaloisConnection.u_eq
File: Mathlib/Order/GaloisConnection.lean

tactic: constructor
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
z : α
y : β
⊢ u y = z ↔ ∀ (x : α), x ≤ z ↔ l x ≤ y
state_after: case mp
α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
z : α
y : β
⊢ u y = z → ∀ (x : α), x ≤ z ↔ l x ≤ y

case mpr
α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
z : α
y : β
⊢ (∀ (x : α), x ≤ z ↔ l x ≤ y) → u y = z

tactic: rintro rfl x
state_before: case mp
α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
z : α
y : β
⊢ u y = z → ∀ (x : α), x ≤ z ↔ l x ≤ y
state_after: case mp
α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
y : β
x : α
⊢ x ≤ u y ↔ l x ≤ y

tactic: exact (gc x y).symm
state_before: case mp
α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
y : β
x : α
⊢ x ≤ u y ↔ l x ≤ y
state_after: no goals

tactic: intro H
state_before: case mpr
α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
z : α
y : β
⊢ (∀ (x : α), x ≤ z ↔ l x ≤ y) → u y = z
state_after: case mpr
α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
z : α
y : β
H : ∀ (x : α), x ≤ z ↔ l x ≤ y
⊢ u y = z

tactic: exact ((H <| u y).mpr (gc.l_u_le y)).antisymm ((gc _ _).mp <| (H z).mp le_rfl)
state_before: case mpr
α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
z : α
y : β
H : ∀ (x : α), x ≤ z ↔ l x ≤ y
⊢ u y = z
state_after: no goals
Theorem: CategoryTheory.Limits.coprodComparison_inv_natural
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: rw [IsIso.eq_comp_inv, Category.assoc, IsIso.inv_comp_eq, coprodComparison_natural]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X Y : C
D : Type u₂
inst✝⁶ : Category.{w, u₂} D
F : C ⥤ D
A A' B B' : C
inst✝⁵ : HasBinaryCoproduct A B
inst✝⁴ : HasBinaryCoproduct A' B'
inst✝³ : HasBinaryCoproduct (F.obj A) (F.obj B)
inst✝² : HasBinaryCoproduct (F.obj A') (F.obj B')
f : A ⟶ A'
g : B ⟶ B'
inst✝¹ : IsIso (coprodComparison F A B)
inst✝ : IsIso (coprodComparison F A' B')
⊢ inv (coprodComparison F A B) ≫ coprod.map (F.map f) (F.map g) =
    F.map (coprod.map f g) ≫ inv (coprodComparison F A' B')
state_after: no goals
Theorem: lineDerivWithin_univ
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

tactic: simp [lineDerivWithin, lineDeriv]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
f f₁ : E → F
f' f₀' f₁' : F
s t : Set E
x v : E
⊢ lineDerivWithin 𝕜 f univ x v = lineDeriv 𝕜 f x v
state_after: no goals
Theorem: LowerSet.supIrred_Iic
File: Mathlib/Order/Birkhoff.lean

tactic: refine ⟨fun h ↦ Iic_ne_bot h.eq_bot, fun s t hst ↦ ?_⟩
state_before: α : Type u_1
inst✝ : PartialOrder α
s : LowerSet α
a : α
⊢ SupIrred (Iic a)
state_after: α : Type u_1
inst✝ : PartialOrder α
s✝ : LowerSet α
a : α
s t : LowerSet α
hst : s ⊔ t = Iic a
⊢ s = Iic a ∨ t = Iic a

tactic: have := mem_Iic_iff.2 (le_refl a)
state_before: α : Type u_1
inst✝ : PartialOrder α
s✝ : LowerSet α
a : α
s t : LowerSet α
hst : s ⊔ t = Iic a
⊢ s = Iic a ∨ t = Iic a
state_after: α : Type u_1
inst✝ : PartialOrder α
s✝ : LowerSet α
a : α
s t : LowerSet α
hst : s ⊔ t = Iic a
this : a ∈ Iic a
⊢ s = Iic a ∨ t = Iic a

tactic: rw [← hst] at this
state_before: α : Type u_1
inst✝ : PartialOrder α
s✝ : LowerSet α
a : α
s t : LowerSet α
hst : s ⊔ t = Iic a
this : a ∈ Iic a
⊢ s = Iic a ∨ t = Iic a
state_after: α : Type u_1
inst✝ : PartialOrder α
s✝ : LowerSet α
a : α
s t : LowerSet α
hst : s ⊔ t = Iic a
this : a ∈ s ⊔ t
⊢ s = Iic a ∨ t = Iic a

tactic: exact this.imp (fun ha ↦ (le_sup_left.trans_eq hst).antisymm <| Iic_le.2 ha) fun ha ↦
  (le_sup_right.trans_eq hst).antisymm <| Iic_le.2 ha
state_before: α : Type u_1
inst✝ : PartialOrder α
s✝ : LowerSet α
a : α
s t : LowerSet α
hst : s ⊔ t = Iic a
this : a ∈ s ⊔ t
⊢ s = Iic a ∨ t = Iic a
state_after: no goals
Theorem: Cubic.mem_roots_iff
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [roots, mem_roots h0, IsRoot, toPoly]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic R
inst✝² : CommRing R
inst✝¹ : CommRing S
φ : R →+* S
inst✝ : IsDomain R
h0 : P.toPoly ≠ 0
x : R
⊢ x ∈ P.roots ↔ P.a * x ^ 3 + P.b * x ^ 2 + P.c * x + P.d = 0
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic R
inst✝² : CommRing R
inst✝¹ : CommRing S
φ : R →+* S
inst✝ : IsDomain R
h0 : P.toPoly ≠ 0
x : R
⊢ eval x (C P.a * X ^ 3 + C P.b * X ^ 2 + C P.c * X + C P.d) = 0 ↔ P.a * x ^ 3 + P.b * x ^ 2 + P.c * x + P.d = 0

tactic: simp only [eval_C, eval_X, eval_add, eval_mul, eval_pow]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic R
inst✝² : CommRing R
inst✝¹ : CommRing S
φ : R →+* S
inst✝ : IsDomain R
h0 : P.toPoly ≠ 0
x : R
⊢ eval x (C P.a * X ^ 3 + C P.b * X ^ 2 + C P.c * X + C P.d) = 0 ↔ P.a * x ^ 3 + P.b * x ^ 2 + P.c * x + P.d = 0
state_after: no goals
Theorem: uniformContinuous_pi
File: Mathlib/Topology/UniformSpace/Pi.lean

tactic: simp only [UniformContinuous, Pi.uniformity, tendsto_iInf, tendsto_comap_iff, Function.comp]
state_before: ι : Type u_1
ι' : Type u_2
β✝ : Type u_3
α : ι → Type u
U : (i : ι) → UniformSpace (α i)
inst✝¹ : UniformSpace β✝
β : Type u_4
inst✝ : UniformSpace β
f : β → (i : ι) → α i
⊢ UniformContinuous f ↔ ∀ (i : ι), UniformContinuous fun x => f x i
state_after: no goals
Theorem: List.get_cyclicPermutations
File: Mathlib/Data/List/Rotate.lean

tactic: simp
state_before: α : Type u
l✝ l' l : List α
n : Fin l.cyclicPermutations.length
⊢ l.cyclicPermutations.get n = l.rotate ↑n
state_after: no goals
Theorem: CategoryTheory.Subgroupoid.sInf_isNormal
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

tactic: simp_rw [sInf, mem_iInter₂]
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
s : Set (Subgroupoid C)
sn : ∀ S ∈ s, S.IsNormal
⊢ ∀ (c : C), 𝟙 c ∈ (sInf s).arrows c c
state_after: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
s : Set (Subgroupoid C)
sn : ∀ S ∈ s, S.IsNormal
⊢ ∀ (c : C), ∀ i ∈ s, 𝟙 c ∈ i.arrows c c

tactic: exact fun c S Ss => (sn S Ss).wide c
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
s : Set (Subgroupoid C)
sn : ∀ S ∈ s, S.IsNormal
⊢ ∀ (c : C), ∀ i ∈ s, 𝟙 c ∈ i.arrows c c
state_after: no goals

tactic: simp_rw [sInf, mem_iInter₂]
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
s : Set (Subgroupoid C)
sn : ∀ S ∈ s, S.IsNormal
⊢ ∀ {c d : C} (p : c ⟶ d) {γ : c ⟶ c}, γ ∈ (sInf s).arrows c c → Groupoid.inv p ≫ γ ≫ p ∈ (sInf s).arrows d d
state_after: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
s : Set (Subgroupoid C)
sn : ∀ S ∈ s, S.IsNormal
⊢ ∀ {c d : C} (p : c ⟶ d) {γ : c ⟶ c}, (∀ i ∈ s, γ ∈ i.arrows c c) → ∀ i ∈ s, Groupoid.inv p ≫ γ ≫ p ∈ i.arrows d d

tactic: exact fun p γ hγ S Ss => (sn S Ss).conj p (hγ S Ss)
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
s : Set (Subgroupoid C)
sn : ∀ S ∈ s, S.IsNormal
⊢ ∀ {c d : C} (p : c ⟶ d) {γ : c ⟶ c}, (∀ i ∈ s, γ ∈ i.arrows c c) → ∀ i ∈ s, Groupoid.inv p ≫ γ ≫ p ∈ i.arrows d d
state_after: no goals
Theorem: ArithmeticFunction.vonMangoldt_apply_pow
File: Mathlib/NumberTheory/VonMangoldt.lean

tactic: simp only [vonMangoldt_apply, isPrimePow_pow_iff hk, pow_minFac hk]
state_before: n k : ℕ
hk : k ≠ 0
⊢ Λ (n ^ k) = Λ n
state_after: no goals
Theorem: PosSMulMono.of_pos
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: obtain ha | ha := ha.eq_or_lt
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝⁴ : Zero α
inst✝³ : Zero β
inst✝² : SMulWithZero α β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
h₀ : ∀ (a : α), 0 < a → ∀ (b₁ b₂ : β), b₁ ≤ b₂ → a • b₁ ≤ a • b₂
a : α
ha : 0 ≤ a
b₁ b₂ : β
h : b₁ ≤ b₂
⊢ a • b₁ ≤ a • b₂
state_after: case inl
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝⁴ : Zero α
inst✝³ : Zero β
inst✝² : SMulWithZero α β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
h₀ : ∀ (a : α), 0 < a → ∀ (b₁ b₂ : β), b₁ ≤ b₂ → a • b₁ ≤ a • b₂
a : α
ha✝ : 0 ≤ a
b₁ b₂ : β
h : b₁ ≤ b₂
ha : 0 = a
⊢ a • b₁ ≤ a • b₂

case inr
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝⁴ : Zero α
inst✝³ : Zero β
inst✝² : SMulWithZero α β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
h₀ : ∀ (a : α), 0 < a → ∀ (b₁ b₂ : β), b₁ ≤ b₂ → a • b₁ ≤ a • b₂
a : α
ha✝ : 0 ≤ a
b₁ b₂ : β
h : b₁ ≤ b₂
ha : 0 < a
⊢ a • b₁ ≤ a • b₂

tactic: simp [← ha]
state_before: case inl
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝⁴ : Zero α
inst✝³ : Zero β
inst✝² : SMulWithZero α β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
h₀ : ∀ (a : α), 0 < a → ∀ (b₁ b₂ : β), b₁ ≤ b₂ → a • b₁ ≤ a • b₂
a : α
ha✝ : 0 ≤ a
b₁ b₂ : β
h : b₁ ≤ b₂
ha : 0 = a
⊢ a • b₁ ≤ a • b₂
state_after: no goals

tactic: exact h₀ _ ha _ _ h
state_before: case inr
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝⁴ : Zero α
inst✝³ : Zero β
inst✝² : SMulWithZero α β
inst✝¹ : PartialOrder α
inst✝ : Preorder β
h₀ : ∀ (a : α), 0 < a → ∀ (b₁ b₂ : β), b₁ ≤ b₂ → a • b₁ ≤ a • b₂
a : α
ha✝ : 0 ≤ a
b₁ b₂ : β
h : b₁ ≤ b₂
ha : 0 < a
⊢ a • b₁ ≤ a • b₂
state_after: no goals
Theorem: HurwitzZeta.hasSum_int_hurwitzZetaOdd
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

tactic: refine ((hasSum_int_completedHurwitzZetaOdd a hs).div_const (Gammaℝ _)).congr_fun fun n ↦ ?_
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ HasSum (fun n => ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2) (hurwitzZetaOdd (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
⊢ ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 =
    (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 / (s + 1).Gammaℝ

tactic: have : 0 < re (s + 1) := by rw [add_re, one_re]; positivity
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
⊢ ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 =
    (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 / (s + 1).Gammaℝ
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
this : 0 < (s + 1).re
⊢ ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 =
    (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 / (s + 1).Gammaℝ

tactic: simp only [div_right_comm _ _ (Gammaℝ _), mul_div_cancel_left₀ _ (Gammaℝ_ne_zero_of_re_pos this)]
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
this : 0 < (s + 1).re
⊢ ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 =
    (s + 1).Gammaℝ * ↑(SignType.sign (↑n + a)) / ↑|↑n + a| ^ s / 2 / (s + 1).Gammaℝ
state_after: no goals

tactic: rw [add_re, one_re]
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
⊢ 0 < (s + 1).re
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
⊢ 0 < s.re + 1

tactic: positivity
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
⊢ 0 < s.re + 1
state_after: no goals
Theorem: Ordinal.enumOrd_zero
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [enumOrd_def]
state_before: S : Set Ordinal.{u}
⊢ enumOrd S 0 = sInf S
state_after: S : Set Ordinal.{u}
⊢ sInf (S ∩ {b | ∀ c < 0, enumOrd S c < b}) = sInf S

tactic: simp [Ordinal.not_lt_zero]
state_before: S : Set Ordinal.{u}
⊢ sInf (S ∩ {b | ∀ c < 0, enumOrd S c < b}) = sInf S
state_after: no goals
Theorem: CategoryTheory.GlueData.ι_gluedIso_inv
File: Mathlib/CategoryTheory/GlueData.lean

tactic: rw [Iso.comp_inv_eq, ι_gluedIso_hom]
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (D.f i j) (D.f i k)) F
inst✝¹ : HasMulticoequalizer D.diagram
inst✝ : PreservesColimit D.diagram.multispan F
i : D.J
⊢ (D.mapGlueData F).ι i ≫ (D.gluedIso F).inv = F.map (D.ι i)
state_after: no goals