ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: WeierstrassCurve.coeff_preΨ₄
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ W.preΨ₄.coeff 6 = 2
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ (2 * X ^ 6 + C W.b₂ * X ^ 5 + 5 * C W.b₄ * X ^ 4 + 10 * C W.b₆ * X ^ 3 + 10 * C W.b₈ * X ^ 2 +
            C (W.b₂ * W.b₈ - W.b₄ * W.b₆) * X +
          C (W.b₄ * W.b₈ - W.b₆ ^ 2)).coeff
      6 =
    2
tactic: rw [preΨ₄]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ (2 * X ^ 6 + C W.b₂ * X ^ 5 + 5 * C W.b₄ * X ^ 4 + 10 * C W.b₆ * X ^ 3 + 10 * C W.b₈ * X ^ 2 +
            C (W.b₂ * W.b₈ - W.b₄ * W.b₆) * X +
          C (W.b₄ * W.b₈ - W.b₆ ^ 2)).coeff
      6 =
    2
state_after: no goals
tactic: compute_degree!
Theorem: eq_one_iff_eq_one_of_mul_eq_one
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M✝ : Type u_4
M : Type u
inst✝ : MulOneClass M
a b : M
h : a * b = 1
⊢ a = 1 ↔ b = 1
state_after: no goals
tactic: constructor <;> (rintro rfl; simpa using h)
Theorem: Finset.shadow_iterate_empty
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k✝ r k : ℕ
⊢ ∂ ^[k] ∅ = ∅
state_after: no goals
tactic: induction' k <;> simp [*, shadow_empty]
Theorem: le_padicValNat_iff_replicate_subperm_primeFactorsList
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p a b n : ℕ
ha : Nat.Prime a
hb : b ≠ 0
⊢ n ≤ padicValNat a b ↔ replicate n a <+~ b.primeFactorsList
state_after: no goals
tactic: rw [← le_multiplicity_iff_replicate_subperm_primeFactorsList ha hb,
    ← padicValNat_def' ha.ne_one (Nat.pos_of_ne_zero hb), Nat.cast_le]
Theorem: Ordinal.blsub_eq_blsub
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r r' : ι → ι → Prop
inst✝¹ : IsWellOrder ι r
inst✝ : IsWellOrder ι r'
f : ι → Ordinal.{max u v}
⊢ (type r).blsub (bfamilyOfFamily' r f) = (type r').blsub (bfamilyOfFamily' r' f)
state_after: no goals
tactic: rw [blsub_eq_lsub', blsub_eq_lsub']
Theorem: Algebra.PreSubmersivePresentation.jacobiMatrix_apply
File: Mathlib/RingTheory/Smooth/StandardSmooth.lean

Proof steps:
state_before: n : ℕ
R : Type u
inst✝⁴ : CommRing R
S : Type v
inst✝³ : CommRing S
inst✝² : Algebra R S
P : PreSubmersivePresentation R S
inst✝¹ : Fintype P.rels
inst✝ : DecidableEq P.rels
i j : P.rels
⊢ P.jacobiMatrix i j = (MvPolynomial.pderiv (P.map i)) (P.relation j)
state_after: no goals
tactic: simp [jacobiMatrix, LinearMap.toMatrix, differential]
Theorem: ContDiffOn.sub
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s✝ s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
s : Set E
f g : E → F
hf : ContDiffOn 𝕜 n f s
hg : ContDiffOn 𝕜 n g s
⊢ ContDiffOn 𝕜 n (fun x => f x - g x) s
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
Theorem: MeasurableSet.everywherePosSubset
File: Mathlib/MeasureTheory/Measure/EverywherePos.lean

Proof steps:
state_before: α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ ν : Measure α
s k : Set α
inst✝ : OpensMeasurableSpace α
hs : MeasurableSet s
⊢ MeasurableSet (μ.everywherePosSubset s)
state_after: case intro.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ ν : Measure α
s k : Set α
inst✝ : OpensMeasurableSpace α
hs : MeasurableSet s
u : Set α
u_open : IsOpen u
hu : μ.everywherePosSubset s = s \ u
⊢ MeasurableSet (μ.everywherePosSubset s)
tactic: rcases exists_isOpen_everywherePosSubset_eq_diff μ s with ⟨u, u_open, hu⟩
state_before: case intro.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ ν : Measure α
s k : Set α
inst✝ : OpensMeasurableSpace α
hs : MeasurableSet s
u : Set α
u_open : IsOpen u
hu : μ.everywherePosSubset s = s \ u
⊢ MeasurableSet (μ.everywherePosSubset s)
state_after: case intro.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ ν : Measure α
s k : Set α
inst✝ : OpensMeasurableSpace α
hs : MeasurableSet s
u : Set α
u_open : IsOpen u
hu : μ.everywherePosSubset s = s \ u
⊢ MeasurableSet (s \ u)
tactic: rw [hu]
state_before: case intro.intro
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : MeasurableSpace α
μ ν : Measure α
s k : Set α
inst✝ : OpensMeasurableSpace α
hs : MeasurableSet s
u : Set α
u_open : IsOpen u
hu : μ.everywherePosSubset s = s \ u
⊢ MeasurableSet (s \ u)
state_after: no goals
tactic: exact hs.diff u_open.measurableSet
Theorem: Order.pred_le_le_iff
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a✝ b✝ a b : α
⊢ pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = pred a
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a✝ b✝ a b : α
⊢ b = a ∨ b = pred a → pred a ≤ b ∧ b ≤ a
tactic: refine
    ⟨fun h =>
      or_iff_not_imp_left.2 fun hba : b ≠ a => (le_pred_of_lt <| h.2.lt_of_ne hba).antisymm h.1, ?_⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a✝ b✝ a b : α
⊢ b = a ∨ b = pred a → pred a ≤ b ∧ b ≤ a
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b✝ b : α
⊢ pred b ≤ b ∧ b ≤ b

case inr
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a✝ b a : α
⊢ pred a ≤ pred a ∧ pred a ≤ a
tactic: rintro (rfl | rfl)
Theorem: IsSemisimpleModule.eq_bot_or_exists_simple_le
File: Mathlib/RingTheory/SimpleModule.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁶ : Ring R
inst✝⁵ : Ring S
M : Type u_4
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N✝ : Type u_5
inst✝² : AddCommGroup N✝
inst✝¹ : Module R N✝
inst✝ : IsSemisimpleModule R M
N : Submodule R M
⊢ N = ⊥ ∨ ∃ m ≤ N, IsSimpleModule R ↥m
state_after: no goals
tactic: simpa only [isSimpleModule_iff_isAtom, and_comm] using eq_bot_or_exists_atom_le _
Theorem: CategoryTheory.Equivalence.cancel_unitInv_right
File: Mathlib/CategoryTheory/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
X Y : C
f f' : X ⟶ e.inverse.obj (e.functor.obj Y)
⊢ f ≫ e.unitInv.app Y = f' ≫ e.unitInv.app Y ↔ f = f'
state_after: no goals
tactic: simp only [cancel_mono]
Theorem: Real.rpow_add_one'
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
h : y + 1 ≠ 0
⊢ x ^ (y + 1) = x ^ y * x
state_after: no goals
tactic: rw [rpow_add' hx h, rpow_one]
Theorem: tsub_add_eq_max
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ a - b + b = max a b
state_after: case inl
α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : a ≤ b
⊢ a - b + b = max a b

case inr
α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : b ≤ a
⊢ a - b + b = max a b
tactic: rcases le_total a b with h | h
Theorem: Cardinal.natCast_lt
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
m n : ℕ
⊢ ↑m < ↑n ↔ m < n
state_after: α β : Type u
m n : ℕ
⊢ ↑m ≤ ↑n ∧ ¬↑n ≤ ↑m ↔ ¬n ≤ m
tactic: rw [lt_iff_le_not_le, ← not_le]
state_before: α β : Type u
m n : ℕ
⊢ ↑m ≤ ↑n ∧ ¬↑n ≤ ↑m ↔ ¬n ≤ m
state_after: α β : Type u
m n : ℕ
⊢ m < n → m ≤ n
tactic: simp only [natCast_le, not_le, and_iff_right_iff_imp]
state_before: α β : Type u
m n : ℕ
⊢ m < n → m ≤ n
state_after: no goals
tactic: exact fun h ↦ le_of_lt h
Theorem: OrderIso.equivalence_unitIso
File: Mathlib/CategoryTheory/Category/Preorder.lean

Proof steps:
state_before: X : Type u
Y : Type v
inst✝¹ : Preorder X
inst✝ : Preorder Y
e : X ≃o Y
x✝ : X
⊢ (𝟭 X).obj x✝ = (⋯.functor ⋙ ⋯.functor).obj x✝
state_after: no goals
tactic: simp
state_before: X : Type u
Y : Type v
inst✝¹ : Preorder X
inst✝ : Preorder Y
e : X ≃o Y
x✝ : Y
⊢ (⋯.functor ⋙ ⋯.functor).obj x✝ = (𝟭 Y).obj x✝
state_after: no goals
tactic: simp
Theorem: AList.insert_insert_of_ne
File: Mathlib/Data/List/AList.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
b : β a
b' : β a'
s : AList β
h : a ≠ a'
⊢ (insert a' b' (insert a b s)).entries ~ (insert a b (insert a' b' s)).entries
state_after: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
b : β a
b' : β a'
s : AList β
h : a ≠ a'
⊢ ⟨a', b'⟩ :: kerase a' (⟨a, b⟩ :: kerase a s.entries) ~ ⟨a, b⟩ :: kerase a (⟨a', b'⟩ :: kerase a' s.entries)
tactic: simp only [insert_entries]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
b : β a
b' : β a'
s : AList β
h : a ≠ a'
⊢ ⟨a', b'⟩ :: kerase a' (⟨a, b⟩ :: kerase a s.entries) ~ ⟨a, b⟩ :: kerase a (⟨a', b'⟩ :: kerase a' s.entries)
state_after: no goals
tactic: rw [kerase_cons_ne, kerase_cons_ne, kerase_comm] <;>
    [apply Perm.swap; exact h; exact h.symm]
Theorem: Finset.piAntidiag_empty_of_ne_zero
File: Mathlib/Algebra/Order/Antidiag/Pi.lean

Proof steps:
state_before: ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝³ : DecidableEq ι
inst✝² : AddCommMonoid μ
inst✝¹ : HasAntidiagonal μ
inst✝ : DecidableEq μ
n✝ : μ
s : Finset ι
n : μ
f : ι → μ
hn : n ≠ 0
⊢ ∀ (x : ι → μ), x ∉ ∅.piAntidiag n
state_after: no goals
tactic: simp [@eq_comm _ 0, hn.symm]
Theorem: Finset.lt_sup'_iff
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset ι
H : s.Nonempty
f : ι → α
a : α
⊢ a < s.sup' H f ↔ ∃ b ∈ s, a < f b
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset ι
H : s.Nonempty
f : ι → α
a : α
⊢ (∃ b ∈ s, ↑a < (WithBot.some ∘ f) b) ↔ ∃ b ∈ s, a < f b
tactic: rw [← WithBot.coe_lt_coe, coe_sup', Finset.lt_sup_iff]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset ι
H : s.Nonempty
f : ι → α
a : α
⊢ (∃ b ∈ s, ↑a < (WithBot.some ∘ f) b) ↔ ∃ b ∈ s, a < f b
state_after: no goals
tactic: exact exists_congr (fun _ => and_congr_right' WithBot.coe_lt_coe)
Theorem: MeasureTheory.Measure.restrict_congr_meas
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
H : μ.restrict s = ν.restrict s
t : Set α
hts : t ⊆ s
ht : MeasurableSet t
⊢ μ t = ν t
state_after: no goals
tactic: rw [← inter_eq_self_of_subset_left hts, ← restrict_apply ht, H, restrict_apply ht]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
H : ∀ t ⊆ s, MeasurableSet t → μ t = ν t
t : Set α
ht : MeasurableSet t
⊢ (μ.restrict s) t = (ν.restrict s) t
state_after: no goals
tactic: rw [restrict_apply ht, restrict_apply ht, H _ inter_subset_right (ht.inter hs)]
Theorem: ExistsUnique.unique₂
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: α✝ : Sort u_1
β : Sort u_2
p✝ q✝ : α✝ → Prop
α : Sort u_3
p : α → Sort u_4
inst✝ : ∀ (x : α), Subsingleton (p x)
q : (x : α) → p x → Prop
h : ∃! x, ∃! hx, q x hx
y₁ y₂ : α
hpy₁ : p y₁
hqy₁ : q y₁ hpy₁
hpy₂ : p y₂
hqy₂ : q y₂ hpy₂
⊢ y₁ = y₂
state_after: α✝ : Sort u_1
β : Sort u_2
p✝ q✝ : α✝ → Prop
α : Sort u_3
p : α → Sort u_4
inst✝ : ∀ (x : α), Subsingleton (p x)
q : (x : α) → p x → Prop
y₁ y₂ : α
hpy₁ : p y₁
hqy₁ : q y₁ hpy₁
hpy₂ : p y₂
hqy₂ : q y₂ hpy₂
h : ∃! x, ∃ hx, q x hx
⊢ y₁ = y₂
tactic: simp only [exists_unique_iff_exists] at h
state_before: α✝ : Sort u_1
β : Sort u_2
p✝ q✝ : α✝ → Prop
α : Sort u_3
p : α → Sort u_4
inst✝ : ∀ (x : α), Subsingleton (p x)
q : (x : α) → p x → Prop
y₁ y₂ : α
hpy₁ : p y₁
hqy₁ : q y₁ hpy₁
hpy₂ : p y₂
hqy₂ : q y₂ hpy₂
h : ∃! x, ∃ hx, q x hx
⊢ y₁ = y₂
state_after: no goals
tactic: exact h.unique ⟨hpy₁, hqy₁⟩ ⟨hpy₂, hqy₂⟩
Theorem: Nat.one_lt_two_pow'
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
⊢ 1 < 2
state_after: no goals
tactic: decide
Theorem: Filter.pi_neBot
File: Mathlib/Order/Filter/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
⊢ (pi f).NeBot ↔ ∀ (i : ι), (f i).NeBot
state_after: no goals
tactic: simp [neBot_iff]
Theorem: CategoryTheory.LaxBraidedFunctor.mapCommMon_obj_X
File: Mathlib/CategoryTheory/Monoidal/CommMon_.lean

Proof steps:
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
⊢ (β_ __src✝.X __src✝.X).hom ≫ __src✝.mul = __src✝.mul
state_after: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
⊢ (β_ (F.obj A.X) (F.obj A.X)).hom ≫ F.μ A.X A.X ≫ F.map A.mul = F.μ A.X A.X ≫ F.map A.mul
tactic: dsimp
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
⊢ (β_ (F.obj A.X) (F.obj A.X)).hom ≫ F.μ A.X A.X ≫ F.map A.mul = F.μ A.X A.X ≫ F.map A.mul
state_after: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
this : ∀ (X Y : C), F.μ X Y ≫ F.map (β_ X Y).hom = (β_ (F.obj X) (F.obj Y)).hom ≫ F.μ Y X
⊢ (β_ (F.obj A.X) (F.obj A.X)).hom ≫ F.μ A.X A.X ≫ F.map A.mul = F.μ A.X A.X ≫ F.map A.mul
tactic: have := F.braided
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
this : ∀ (X Y : C), F.μ X Y ≫ F.map (β_ X Y).hom = (β_ (F.obj X) (F.obj Y)).hom ≫ F.μ Y X
⊢ (β_ (F.obj A.X) (F.obj A.X)).hom ≫ F.μ A.X A.X ≫ F.map A.mul = F.μ A.X A.X ≫ F.map A.mul
state_after: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
this : ∀ (X Y : C), F.μ X Y ≫ F.map (β_ X Y).hom = (β_ (F.obj X) (F.obj Y)).hom ≫ F.μ Y X
⊢ (F.μ A.X A.X ≫ F.map (β_ A.X A.X).hom) ≫ F.map A.mul = F.μ A.X A.X ≫ F.map A.mul
tactic: slice_lhs 1 2 => rw [← this]
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
F : LaxBraidedFunctor C D
A : CommMon_ C
this : ∀ (X Y : C), F.μ X Y ≫ F.map (β_ X Y).hom = (β_ (F.obj X) (F.obj Y)).hom ≫ F.μ Y X
⊢ (F.μ A.X A.X ≫ F.map (β_ A.X A.X).hom) ≫ F.map A.mul = F.μ A.X A.X ≫ F.map A.mul
state_after: no goals
tactic: slice_lhs 2 3 => rw [← CategoryTheory.Functor.map_comp, A.mul_comm]
Theorem: MixedCharZero.reduce_to_p_prime
File: Mathlib/Algebra/CharP/MixedCharZero.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
P : Prop
⊢ (∀ p > 0, MixedCharZero R p → P) ↔ ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
state_after: case mp
R : Type u_1
inst✝ : CommRing R
P : Prop
⊢ (∀ p > 0, MixedCharZero R p → P) → ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P

case mpr
R : Type u_1
inst✝ : CommRing R
P : Prop
⊢ (∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P) → ∀ p > 0, MixedCharZero R p → P
tactic: constructor
Theorem: ConvexCone.coe_iInf
File: Mathlib/Analysis/Convex/Cone/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
S T : ConvexCone 𝕜 E
ι : Sort u_5
f : ι → ConvexCone 𝕜 E
⊢ ↑(iInf f) = ⋂ i, ↑(f i)
state_after: no goals
tactic: simp [iInf]
Theorem: CategoryTheory.MorphismProperty.isoClosure_eq_self
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{?u.20097, u_1} D
P : MorphismProperty C
inst✝ : P.RespectsIso
⊢ P.isoClosure = P
state_after: no goals
tactic: rwa [isoClosure_eq_iff]
Theorem: Sublattice.map_symm_eq_iff_eq_map
File: Mathlib/Order/Sublattice.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M✝ : Sublattice α
f : LatticeHom α β
s t : Set α
a : α
M : Sublattice β
e : β ≃o α
⊢ map { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ } L = M ↔ L = map { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ } M
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M✝ : Sublattice α
f : LatticeHom α β
s t : Set α
a : α
M : Sublattice β
e : β ≃o α
⊢ ↑(map { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ } L) = ↑M ↔
    ↑L = ↑(map { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ } M)
tactic: simp_rw [← coe_inj]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M✝ : Sublattice α
f : LatticeHom α β
s t : Set α
a : α
M : Sublattice β
e : β ≃o α
⊢ ↑(map { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ } L) = ↑M ↔
    ↑L = ↑(map { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ } M)
state_after: no goals
tactic: exact (Equiv.eq_image_iff_symm_image_eq _ _ _).symm
Theorem: comap_upperCentralSeries_quotient_center
File: Mathlib/GroupTheory/Nilpotent.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
n : ℕ
⊢ comap (mk' (center G)) (upperCentralSeries (G ⧸ center G) n) = upperCentralSeries G n.succ
state_after: case zero
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
⊢ comap (mk' (center G)) (upperCentralSeries (G ⧸ center G) 0) = upperCentralSeries G (Nat.succ 0)

case succ
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
n : ℕ
ih : comap (mk' (center G)) (upperCentralSeries (G ⧸ center G) n) = upperCentralSeries G n.succ
⊢ comap (mk' (center G)) (upperCentralSeries (G ⧸ center G) (n + 1)) = upperCentralSeries G (n + 1).succ
tactic: induction' n with n ih
Theorem: CategoryTheory.Iso.unop_inv
File: Mathlib/CategoryTheory/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X✝ Y✝ : C
X Y : Cᵒᵖ
f : X ≅ Y
⊢ f.hom.unop ≫ f.inv.unop = 𝟙 (Opposite.unop Y)
state_after: no goals
tactic: simp only [← unop_comp, f.inv_hom_id, unop_id]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X✝ Y✝ : C
X Y : Cᵒᵖ
f : X ≅ Y
⊢ f.inv.unop ≫ f.hom.unop = 𝟙 (Opposite.unop X)
state_after: no goals
tactic: simp only [← unop_comp, f.hom_inv_id, unop_id]
Theorem: Complex.cpow_mul
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

Proof steps:
state_before: x y z : ℂ
h₁ : -π < (log x * y).im
h₂ : (log x * y).im ≤ π
⊢ x ^ (y * z) = (x ^ y) ^ z
state_after: x y z : ℂ
h₁ : -π < (log x * y).im
h₂ : (log x * y).im ≤ π
⊢ (if x = 0 then if y * z = 0 then 1 else 0 else cexp (log x * (y * z))) =
    if (if x = 0 then if y = 0 then 1 else 0 else cexp (log x * y)) = 0 then if z = 0 then 1 else 0
    else cexp (log (if x = 0 then if y = 0 then 1 else 0 else cexp (log x * y)) * z)
tactic: simp only [cpow_def]
state_before: x y z : ℂ
h₁ : -π < (log x * y).im
h₂ : (log x * y).im ≤ π
⊢ (if x = 0 then if y * z = 0 then 1 else 0 else cexp (log x * (y * z))) =
    if (if x = 0 then if y = 0 then 1 else 0 else cexp (log x * y)) = 0 then if z = 0 then 1 else 0
    else cexp (log (if x = 0 then if y = 0 then 1 else 0 else cexp (log x * y)) * z)
state_after: no goals
tactic: split_ifs <;> simp_all [exp_ne_zero, log_exp h₁ h₂, mul_assoc]
Theorem: BoundedContinuousFunction.const_apply
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

Proof steps:
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
f g : α →ᵇ β
x : α
C : ℝ
b : β
⊢ ∀ (x y : α), dist ((ContinuousMap.const α b).toFun x) ((ContinuousMap.const α b).toFun y) ≤ 0
state_after: no goals
tactic: simp
Theorem: collinear_iff_finrank_le_one
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
⊢ Collinear k s ↔ finrank k ↥(vectorSpan k s) ≤ 1
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
h : Collinear k s ↔ Module.rank k ↥(vectorSpan k s) ≤ 1
⊢ Collinear k s ↔ finrank k ↥(vectorSpan k s) ≤ 1
tactic: have h := collinear_iff_rank_le_one k s
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
h : Collinear k s ↔ Module.rank k ↥(vectorSpan k s) ≤ 1
⊢ Collinear k s ↔ finrank k ↥(vectorSpan k s) ≤ 1
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
h : Collinear k s ↔ ↑(finrank k ↥(vectorSpan k s)) ≤ 1
⊢ Collinear k s ↔ finrank k ↥(vectorSpan k s) ≤ 1
tactic: rw [← finrank_eq_rank] at h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
h : Collinear k s ↔ ↑(finrank k ↥(vectorSpan k s)) ≤ 1
⊢ Collinear k s ↔ finrank k ↥(vectorSpan k s) ≤ 1
state_after: no goals
tactic: exact mod_cast h
Theorem: SeparationQuotient.t1Space_iff
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
⊢ T1Space (SeparationQuotient X) ↔ R0Space X
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
⊢ (∀ ⦃x y : SeparationQuotient X⦄, x ⤳ y → x = y) ↔ Symmetric Specializes
tactic: rw [r0Space_iff, ((t1Space_TFAE (SeparationQuotient X)).out 0 9 :)]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
⊢ (∀ ⦃x y : SeparationQuotient X⦄, x ⤳ y → x = y) ↔ Symmetric Specializes
state_after: case mp
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
⊢ (∀ ⦃x y : SeparationQuotient X⦄, x ⤳ y → x = y) → Symmetric Specializes

case mpr
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
⊢ Symmetric Specializes → ∀ ⦃x y : SeparationQuotient X⦄, x ⤳ y → x = y
tactic: constructor