ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddLECancellable.add_tsub_tsub_cancel
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hac : AddLECancellable (a - c)
h : c ≤ a
⊢ a + b = b + c + (a - c)
state_after: no goals
tactic: rw [add_assoc, add_tsub_cancel_of_le h, add_comm]
Theorem: MvPolynomial.C_eq_smul_one
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
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
⊢ C a = a • 1
state_after: no goals
tactic: rw [← C_mul', mul_one]
Theorem: lt_of_tsub_lt_tsub_right_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : c ≤ b
h2 : a - c < b - c
⊢ a < b
state_after: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : c ≤ b
h2 : a - c < b - c
⊢ a ≠ b
tactic: refine ((tsub_le_tsub_iff_right h).mp h2.le).lt_of_ne ?_
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : c ≤ b
h2 : a - c < b - c
⊢ a ≠ b
state_after: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a c d : α
h : c ≤ a
h2 : a - c < a - c
⊢ False
tactic: rintro rfl
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a c d : α
h : c ≤ a
h2 : a - c < a - c
⊢ False
state_after: no goals
tactic: exact h2.false
Theorem: MeasureTheory.lintegral_add_right_eq_self
File: Mathlib/MeasureTheory/Group/LIntegral.lean

Proof steps:
state_before: G : Type u_1
inst✝³ : MeasurableSpace G
μ : Measure G
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulRightInvariant
f : G → ℝ≥0∞
g : G
⊢ ∫⁻ (x : G), f (x * g) ∂μ = ∫⁻ (x : G), f x ∂μ
state_after: case h.e'_3
G : Type u_1
inst✝³ : MeasurableSpace G
μ : Measure G
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulRightInvariant
f : G → ℝ≥0∞
g : G
⊢ ∫⁻ (x : G), f x ∂μ = ∫⁻ (a : G), f a ∂map (⇑(MeasurableEquiv.mulRight g)) μ
tactic: convert (lintegral_map_equiv f <| MeasurableEquiv.mulRight g).symm using 1
state_before: case h.e'_3
G : Type u_1
inst✝³ : MeasurableSpace G
μ : Measure G
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulRightInvariant
f : G → ℝ≥0∞
g : G
⊢ ∫⁻ (x : G), f x ∂μ = ∫⁻ (a : G), f a ∂map (⇑(MeasurableEquiv.mulRight g)) μ
state_after: no goals
tactic: simp [map_mul_right_eq_self μ g]
Theorem: AffineSubspace.ext_of_direction_eq
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s1 s2 : AffineSubspace k P
hd : s1.direction = s2.direction
hn : (↑s1 ∩ ↑s2).Nonempty
⊢ s1 = s2
state_after: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s1 s2 : AffineSubspace k P
hd : s1.direction = s2.direction
hn : (↑s1 ∩ ↑s2).Nonempty
p : P
⊢ p ∈ s1 ↔ p ∈ s2
tactic: ext p
state_before: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s1 s2 : AffineSubspace k P
hd : s1.direction = s2.direction
hn : (↑s1 ∩ ↑s2).Nonempty
p : P
⊢ p ∈ s1 ↔ p ∈ s2
state_after: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s1 s2 : AffineSubspace k P
hd : s1.direction = s2.direction
hn : (↑s1 ∩ ↑s2).Nonempty
p : P
hq1 : hn.some ∈ ↑s1
⊢ p ∈ s1 ↔ p ∈ s2
tactic: have hq1 := Set.mem_of_mem_inter_left hn.some_mem
state_before: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s1 s2 : AffineSubspace k P
hd : s1.direction = s2.direction
hn : (↑s1 ∩ ↑s2).Nonempty
p : P
hq1 : hn.some ∈ ↑s1
⊢ p ∈ s1 ↔ p ∈ s2
state_after: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s1 s2 : AffineSubspace k P
hd : s1.direction = s2.direction
hn : (↑s1 ∩ ↑s2).Nonempty
p : P
hq1 : hn.some ∈ ↑s1
hq2 : hn.some ∈ ↑s2
⊢ p ∈ s1 ↔ p ∈ s2
tactic: have hq2 := Set.mem_of_mem_inter_right hn.some_mem
state_before: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s1 s2 : AffineSubspace k P
hd : s1.direction = s2.direction
hn : (↑s1 ∩ ↑s2).Nonempty
p : P
hq1 : hn.some ∈ ↑s1
hq2 : hn.some ∈ ↑s2
⊢ p ∈ s1 ↔ p ∈ s2
state_after: case h.mp
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s1 s2 : AffineSubspace k P
hd : s1.direction = s2.direction
hn : (↑s1 ∩ ↑s2).Nonempty
p : P
hq1 : hn.some ∈ ↑s1
hq2 : hn.some ∈ ↑s2
⊢ p ∈ s1 → p ∈ s2

case h.mpr
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s1 s2 : AffineSubspace k P
hd : s1.direction = s2.direction
hn : (↑s1 ∩ ↑s2).Nonempty
p : P
hq1 : hn.some ∈ ↑s1
hq2 : hn.some ∈ ↑s2
⊢ p ∈ s2 → p ∈ s1
tactic: constructor
Theorem: LieAlgebra.Orthogonal.indefiniteDiagonal_assoc
File: Mathlib/Algebra/Lie/Classical.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁷ : DecidableEq n
inst✝⁶ : DecidableEq p
inst✝⁵ : DecidableEq q
inst✝⁴ : DecidableEq l
inst✝³ : CommRing R
inst✝² : Fintype p
inst✝¹ : Fintype q
inst✝ : Fintype l
⊢ indefiniteDiagonal (Unit ⊕ l) l R =
    (reindexLieEquiv (Equiv.sumAssoc Unit l l).symm) (fromBlocks 1 0 0 (indefiniteDiagonal l l R))
state_after: no goals
tactic: ext ⟨⟨i₁ | i₂⟩ | i₃⟩ ⟨⟨j₁ | j₂⟩ | j₃⟩ <;>
  -- Porting note: added `Sum.inl_injective.eq_iff`, `Sum.inr_injective.eq_iff`
    simp only [indefiniteDiagonal, Matrix.diagonal_apply, Equiv.sumAssoc_apply_inl_inl,
      Matrix.reindexLieEquiv_apply, Matrix.submatrix_apply, Equiv.symm_symm, Matrix.reindex_apply,
      Sum.elim_inl, if_true, eq_self_iff_true, Matrix.one_apply_eq, Matrix.fromBlocks_apply₁₁,
      DMatrix.zero_apply, Equiv.sumAssoc_apply_inl_inr, if_false, Matrix.fromBlocks_apply₁₂,
      Matrix.fromBlocks_apply₂₁, Matrix.fromBlocks_apply₂₂, Equiv.sumAssoc_apply_inr,
      Sum.elim_inr, Sum.inl_injective.eq_iff, Sum.inr_injective.eq_iff] <;>
    congr 1
Theorem: HomogeneousLocalization.val_mul
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁵ : AddCommMonoid ι
inst✝⁴ : DecidableEq ι
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ι → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : Submonoid A
y1 y2 : NumDenSameDeg 𝒜 x
⊢ (Quotient.mk'' y1 * Quotient.mk'' y2).val = val (Quotient.mk'' y1) * val (Quotient.mk'' y2)
state_after: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁵ : AddCommMonoid ι
inst✝⁴ : DecidableEq ι
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ι → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : Submonoid A
y1 y2 : NumDenSameDeg 𝒜 x
⊢ Localization.mk ↑(y1 * y2).num ⟨↑(y1 * y2).den, ⋯⟩ = Localization.mk (↑y1.num * ↑y2.num) (⟨↑y1.den, ⋯⟩ * ⟨↑y2.den, ⋯⟩)
tactic: rw [← mk_mul, val_mk, val_mk, val_mk, Localization.mk_mul]
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁵ : AddCommMonoid ι
inst✝⁴ : DecidableEq ι
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ι → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : Submonoid A
y1 y2 : NumDenSameDeg 𝒜 x
⊢ Localization.mk ↑(y1 * y2).num ⟨↑(y1 * y2).den, ⋯⟩ = Localization.mk (↑y1.num * ↑y2.num) (⟨↑y1.den, ⋯⟩ * ⟨↑y2.den, ⋯⟩)
state_after: no goals
tactic: rfl
Theorem: AddLECancellable.tsub_right_inj
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CanonicallyOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
hb : AddLECancellable b
hc : AddLECancellable c
hba : b ≤ a
hca : c ≤ a
⊢ a - b = a - c ↔ b = c
state_after: no goals
tactic: simp_rw [le_antisymm_iff, ha.tsub_le_tsub_iff_left hb hba, ha.tsub_le_tsub_iff_left hc hca,
    and_comm]
Theorem: LocallyConstant.piecewise_apply_left
File: Mathlib/Topology/LocallyConstant/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
C₁ C₂ : Set X
h₁ : IsClosed C₁
h₂ : IsClosed C₂
h : C₁ ∪ C₂ = univ
f : LocallyConstant (↑C₁) Z
g : LocallyConstant (↑C₂) Z
hfg : ∀ (x : X) (hx : x ∈ C₁ ∩ C₂), f ⟨x, ⋯⟩ = g ⟨x, ⋯⟩
inst✝ : DecidablePred fun x => x ∈ C₁
x : X
hx : x ∈ C₁
⊢ (piecewise h₁ h₂ h f g hfg) x = f ⟨x, hx⟩
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
C₁ C₂ : Set X
h₁ : IsClosed C₁
h₂ : IsClosed C₂
h : C₁ ∪ C₂ = univ
f : LocallyConstant (↑C₁) Z
g : LocallyConstant (↑C₂) Z
hfg : ∀ (x : X) (hx : x ∈ C₁ ∩ C₂), f ⟨x, ⋯⟩ = g ⟨x, ⋯⟩
inst✝ : DecidablePred fun x => x ∈ C₁
x : X
hx : x ∈ C₁
⊢ (if hi : x ∈ C₁ then f ⟨x, hi⟩ else g ⟨x, ⋯⟩) = f ⟨x, hx⟩
tactic: simp only [piecewise, Set.mem_preimage, continuous_subtype_val.restrictPreimage,
    coe_comap, Function.comp_apply, coe_mk]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
C₁ C₂ : Set X
h₁ : IsClosed C₁
h₂ : IsClosed C₂
h : C₁ ∪ C₂ = univ
f : LocallyConstant (↑C₁) Z
g : LocallyConstant (↑C₂) Z
hfg : ∀ (x : X) (hx : x ∈ C₁ ∩ C₂), f ⟨x, ⋯⟩ = g ⟨x, ⋯⟩
inst✝ : DecidablePred fun x => x ∈ C₁
x : X
hx : x ∈ C₁
⊢ (if hi : x ∈ C₁ then f ⟨x, hi⟩ else g ⟨x, ⋯⟩) = f ⟨x, hx⟩
state_after: no goals
tactic: rw [dif_pos hx]
Theorem: WeierstrassCurve.Jacobian.equation_of_Z_eq_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hPz : P z = 0
⊢ W'.Equation P ↔ P y ^ 2 = P x ^ 3
state_after: no goals
tactic: simp only [equation_iff, hPz, add_zero, mul_zero, zero_pow <| OfNat.ofNat_ne_zero _, sub_eq_zero]
Theorem: pos_add_self_iff
File: Mathlib/Algebra/Order/Monoid/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedCommMonoid α
a : α
h : ¬1 < a
⊢ ¬1 < a * a
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedCommMonoid α
a : α
h : a ≤ 1
⊢ a * a ≤ 1
tactic: push_neg at h ⊢
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedCommMonoid α
a : α
h : a ≤ 1
⊢ a * a ≤ 1
state_after: no goals
tactic: exact mul_le_one' h h
Theorem: MulMemClass.mul_mem_add_closure
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

Proof steps:
state_before: M : Type u_1
A : Type u_2
B : Type u_3
R : Type u_4
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
a b : R
ha : a ∈ AddSubmonoid.closure ↑S
hb : b ∈ AddSubmonoid.closure ↑S
⊢ a * b ∈ AddSubmonoid.closure ↑S
state_after: M : Type u_1
A : Type u_2
B : Type u_3
R : Type u_4
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
b : R
hb : b ∈ AddSubmonoid.closure ↑S
⊢ ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * b ∈ AddSubmonoid.closure ↑S
tactic: revert a
state_before: M : Type u_1
A : Type u_2
B : Type u_3
R : Type u_4
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
b : R
hb : b ∈ AddSubmonoid.closure ↑S
⊢ ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * b ∈ AddSubmonoid.closure ↑S
state_after: case mem
M : Type u_1
A : Type u_2
B : Type u_3
R : Type u_4
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
⊢ ∀ x ∈ ↑S, ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * x ∈ AddSubmonoid.closure ↑S

case one
M : Type u_1
A : Type u_2
B : Type u_3
R : Type u_4
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
⊢ ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * 0 ∈ AddSubmonoid.closure ↑S

case mul
M : Type u_1
A : Type u_2
B : Type u_3
R : Type u_4
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : SetLike M R
inst✝ : MulMemClass M R
S : M
⊢ ∀ (x y : R),
    (∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * x ∈ AddSubmonoid.closure ↑S) →
      (∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * y ∈ AddSubmonoid.closure ↑S) →
        ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * (x + y) ∈ AddSubmonoid.closure ↑S
tactic: apply @AddSubmonoid.closure_induction _ _ _
    (fun z => ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * z ∈ AddSubmonoid.closure ↑S)
      _ hb <;> clear hb b
Theorem: Int.cast_div_ofNat_charZero
File: Mathlib/Data/Int/CharZero.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
k : Type u_3
inst✝¹ : DivisionRing k
inst✝ : CharZero k
m n : ℕ
n_dvd : n ∣ m
⊢ ↑(↑m / ↑n) = ↑m / ↑n
state_after: no goals
tactic: rw [cast_div_charZero (Int.ofNat_dvd.mpr n_dvd), cast_natCast, cast_natCast]
Theorem: WeierstrassCurve.Jacobian.addY_of_Z_eq_zero_left
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hP : W'.Equation P
hPz : P z = 0
⊢ W'.addY P Q = (P x * Q z) ^ 3 * Q y
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hP : W'.Equation P
hPz : P z = 0
⊢ -((P x * Q z) ^ 3 * (-Q y - W'.a₁ * Q x * Q z - W'.a₃ * Q z ^ 3)) -
        W'.a₁ * ((P x * Q z) ^ 2 * Q x) * (P x * Q z * Q z) -
      W'.a₃ * (P x * Q z * Q z) ^ 3 =
    (P x * Q z) ^ 3 * Q y
tactic: simp only [addY, addX_of_Z_eq_zero_left hPz, negAddY_of_Z_eq_zero_left hP hPz,
    addZ_of_Z_eq_zero_left hPz, negY, fin3_def_ext]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hP : W'.Equation P
hPz : P z = 0
⊢ -((P x * Q z) ^ 3 * (-Q y - W'.a₁ * Q x * Q z - W'.a₃ * Q z ^ 3)) -
        W'.a₁ * ((P x * Q z) ^ 2 * Q x) * (P x * Q z * Q z) -
      W'.a₃ * (P x * Q z * Q z) ^ 3 =
    (P x * Q z) ^ 3 * Q y
state_after: no goals
tactic: ring1
Theorem: prime_two_or_dvd_of_dvd_two_mul_pow_self_two
File: Mathlib/RingTheory/Int/Basic.lean

Proof steps:
state_before: m : ℤ
p : ℕ
hp : Nat.Prime p
h : ↑p ∣ 2 * m ^ 2
⊢ p = 2 ∨ p ∣ m.natAbs
state_after: case inl
m : ℤ
p : ℕ
hp : Nat.Prime p
h : ↑p ∣ 2 * m ^ 2
hp2 : p ∣ Int.natAbs 2
⊢ p = 2 ∨ p ∣ m.natAbs

case inr
m : ℤ
p : ℕ
hp : Nat.Prime p
h : ↑p ∣ 2 * m ^ 2
hpp : p ∣ (m ^ 2).natAbs
⊢ p = 2 ∨ p ∣ m.natAbs
tactic: cases' Int.Prime.dvd_mul hp h with hp2 hpp
Theorem: commProb_def'
File: Mathlib/GroupTheory/CommutingProbability.lean

Proof steps:
state_before: M : Type u_1
inst✝² : Mul M
inst✝¹ : Finite M
G : Type u_2
inst✝ : Group G
⊢ commProb G = ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)
state_after: M : Type u_1
inst✝² : Mul M
inst✝¹ : Finite M
G : Type u_2
inst✝ : Group G
⊢ ↑(Nat.card (ConjClasses G)) * ↑(Nat.card G) / (↑(Nat.card G) * ↑(Nat.card G)) =
    ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)
tactic: rw [commProb, card_comm_eq_card_conjClasses_mul_card, Nat.cast_mul, sq]
state_before: M : Type u_1
inst✝² : Mul M
inst✝¹ : Finite M
G : Type u_2
inst✝ : Group G
⊢ ↑(Nat.card (ConjClasses G)) * ↑(Nat.card G) / (↑(Nat.card G) * ↑(Nat.card G)) =
    ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)
state_after: case pos
M : Type u_1
inst✝² : Mul M
inst✝¹ : Finite M
G : Type u_2
inst✝ : Group G
h : ↑(Nat.card G) = 0
⊢ ↑(Nat.card (ConjClasses G)) * ↑(Nat.card G) / (↑(Nat.card G) * ↑(Nat.card G)) =
    ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)

case neg
M : Type u_1
inst✝² : Mul M
inst✝¹ : Finite M
G : Type u_2
inst✝ : Group G
h : ¬↑(Nat.card G) = 0
⊢ ↑(Nat.card (ConjClasses G)) * ↑(Nat.card G) / (↑(Nat.card G) * ↑(Nat.card G)) =
    ↑(Nat.card (ConjClasses G)) / ↑(Nat.card G)
tactic: by_cases h : (Nat.card G : ℚ) = 0
Theorem: LinearMap.BilinForm.dualSubmoduleToDual_apply_apply
File: Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean

Proof steps:
state_before: R : Type ?u.47046
S : Type ?u.47049
M : Type ?u.47052
inst✝⁷ : CommRing R
inst✝⁶ : Field S
inst✝⁵ : AddCommGroup M
inst✝⁴ : Algebra R S
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : IsScalarTower R S M
B : BilinForm S M
inst✝ : NoZeroSMulDivisors R S
N : Submodule R M
x✝ : ↥(B.dualSubmodule N)
x y : ↥N
⊢ (algebraMap R S) (B.dualSubmoduleParing x✝ (x + y)) =
    (algebraMap R S) (B.dualSubmoduleParing x✝ x + B.dualSubmoduleParing x✝ y)
state_after: no goals
tactic: simp
state_before: R : Type ?u.47046
S : Type ?u.47049
M : Type ?u.47052
inst✝⁷ : CommRing R
inst✝⁶ : Field S
inst✝⁵ : AddCommGroup M
inst✝⁴ : Algebra R S
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : IsScalarTower R S M
B : BilinForm S M
inst✝ : NoZeroSMulDivisors R S
N : Submodule R M
x : ↥(B.dualSubmodule N)
r : R
m : ↥N
⊢ (algebraMap R S) ({ toFun := B.dualSubmoduleParing x, map_add' := ⋯ }.toFun (r • m)) =
    (algebraMap R S) ((RingHom.id R) r • { toFun := B.dualSubmoduleParing x, map_add' := ⋯ }.toFun m)
state_after: no goals
tactic: simp [← Algebra.smul_def]
state_before: R : Type ?u.47046
S : Type ?u.47049
M : Type ?u.47052
inst✝⁷ : CommRing R
inst✝⁶ : Field S
inst✝⁵ : AddCommGroup M
inst✝⁴ : Algebra R S
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : IsScalarTower R S M
B : BilinForm S M
inst✝ : NoZeroSMulDivisors R S
N : Submodule R M
x y : ↥(B.dualSubmodule N)
z : ↥N
⊢ (algebraMap R S) (((fun x => { toFun := B.dualSubmoduleParing x, map_add' := ⋯, map_smul' := ⋯ }) (x + y)) z) =
    (algebraMap R S)
      (((fun x => { toFun := B.dualSubmoduleParing x, map_add' := ⋯, map_smul' := ⋯ }) x +
          (fun x => { toFun := B.dualSubmoduleParing x, map_add' := ⋯, map_smul' := ⋯ }) y)
        z)
state_after: no goals
tactic: simp
state_before: R : Type ?u.47046
S : Type ?u.47049
M : Type ?u.47052
inst✝⁷ : CommRing R
inst✝⁶ : Field S
inst✝⁵ : AddCommGroup M
inst✝⁴ : Algebra R S
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : IsScalarTower R S M
B : BilinForm S M
inst✝ : NoZeroSMulDivisors R S
N : Submodule R M
r : R
x : ↥(B.dualSubmodule N)
y : ↥N
⊢ (algebraMap R S)
      (({ toFun := fun x => { toFun := B.dualSubmoduleParing x, map_add' := ⋯, map_smul' := ⋯ }, map_add' := ⋯ }.toFun
          (r • x))
        y) =
    (algebraMap R S)
      (((RingHom.id R) r •
          { toFun := fun x => { toFun := B.dualSubmoduleParing x, map_add' := ⋯, map_smul' := ⋯ }, map_add' := ⋯ }.toFun
            x)
        y)
state_after: no goals
tactic: simp [← Algebra.smul_def]
Theorem: Real.arcsin_eq_of_sin_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y✝ x y : ℝ
h₁ : sin x = y
h₂ : x ∈ Icc (-(π / 2)) (π / 2)
⊢ arcsin y = x
state_after: x✝ y x : ℝ
h₂ : x ∈ Icc (-(π / 2)) (π / 2)
⊢ arcsin (sin x) = x
tactic: subst y
state_before: x✝ y x : ℝ
h₂ : x ∈ Icc (-(π / 2)) (π / 2)
⊢ arcsin (sin x) = x
state_after: no goals
tactic: exact injOn_sin (arcsin_mem_Icc _) h₂ (sin_arcsin' (sin_mem_Icc x))
Theorem: AddAction.aestabilizer_empty
File: Mathlib/MeasureTheory/Group/AEStabilizer.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝² : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
g : G
s t : Set α
x✝¹ : G
x✝ : x✝¹ ∈ ⊤
⊢ x✝¹ ∈ aestabilizer G μ ∅
state_after: no goals
tactic: simp
Theorem: logDeriv_const
File: Mathlib/Analysis/Calculus/LogDeriv.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
a : 𝕜'
⊢ (logDeriv fun x => a) = 0
state_after: case h
𝕜 : Type u_1
𝕜' : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
a : 𝕜'
x✝ : 𝕜
⊢ logDeriv (fun x => a) x✝ = 0 x✝
tactic: ext
state_before: case h
𝕜 : Type u_1
𝕜' : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
a : 𝕜'
x✝ : 𝕜
⊢ logDeriv (fun x => a) x✝ = 0 x✝
state_after: no goals
tactic: simp [logDeriv_apply]
Theorem: Equiv.Perm.isThreeCycle_swap_mul_swap_same
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b c : α
ab : a ≠ b
ac : a ≠ c
bc : b ≠ c
⊢ (swap a b * swap a c).IsThreeCycle
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b c : α
ab : a ≠ b
ac : a ≠ c
bc : b ≠ c
⊢ (swap a b * swap a c).support = {a, b, c}
tactic: suffices h : support (swap a b * swap a c) = {a, b, c} by
    rw [← card_support_eq_three_iff, h]
    simp [ab, ac, bc]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b c : α
ab : a ≠ b
ac : a ≠ c
bc : b ≠ c
⊢ (swap a b * swap a c).support = {a, b, c}
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b c : α
ab : a ≠ b
ac : a ≠ c
bc : b ≠ c
⊢ ∀ x ∈ (swap a b).support ⊔ (swap a c).support, x ∈ {a, b, c}

α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b c : α
ab : a ≠ b
ac : a ≠ c
bc : b ≠ c
x : α
hx : x ∈ {a, b, c}
⊢ x ∈ (swap a b * swap a c).support
tactic: apply le_antisymm ((support_mul_le _ _).trans fun x => _) fun x hx => ?_
Theorem: LieSubmodule.mapsTo_pow_toEnd_sub_algebraMap
File: Mathlib/Algebra/Lie/OfAssociative.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x✝ : L
φ : R
k : ℕ
x : L
⊢ MapsTo ⇑(((toEnd R L M) x - (algebraMap R (Module.End R M)) φ) ^ k) ↑N ↑N
state_after: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x✝ : L
φ : R
k : ℕ
x : L
⊢ MapsTo (⇑((toEnd R L M) x - (algebraMap R (Module.End R M)) φ))^[k] ↑N ↑N
tactic: rw [LinearMap.coe_pow]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x✝ : L
φ : R
k : ℕ
x : L
⊢ MapsTo (⇑((toEnd R L M) x - (algebraMap R (Module.End R M)) φ))^[k] ↑N ↑N
state_after: no goals
tactic: exact MapsTo.iterate (fun m hm ↦ N.sub_mem (N.lie_mem hm) (N.smul_mem _ hm)) k