ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsNoetherian.subsingleton_of_prod_injective
File: Mathlib/RingTheory/Noetherian.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
f : M × N →ₗ[R] M
i : Injective ⇑f
x y : N
⊢ x = y
state_after: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
f : M × N →ₗ[R] M
i : Injective ⇑f
x y : N
h : Injective ⇑(LinearMap.fst R M N)
⊢ x = y
tactic: have h := IsNoetherian.injective_of_surjective_of_injective f _ i LinearMap.fst_surjective
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
f : M × N →ₗ[R] M
i : Injective ⇑f
x y : N
h : Injective ⇑(LinearMap.fst R M N)
⊢ x = y
state_after: no goals
tactic: simpa using h (show LinearMap.fst R M N (0, x) = LinearMap.fst R M N (0, y) from rfl)
Theorem: HomologicalComplex₂.ιTotal_totalFlipIso_f_inv
File: Mathlib/Algebra/Homology/TotalComplexSymmetry.lean

Proof steps:
state_before: C : Type u_1
I₁ : Type u_2
I₂ : Type u_3
J : Type u_4
inst✝⁷ : Category.{?u.40441, u_1} C
inst✝⁶ : Preadditive C
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
c : ComplexShape J
inst✝⁵ : TotalComplexShape c₁ c₂ c
inst✝⁴ : TotalComplexShape c₂ c₁ c
inst✝³ : TotalComplexShapeSymmetry c₁ c₂ c
inst✝² : K.HasTotal c
inst✝¹ : K.flip.HasTotal c
inst✝ : DecidableEq J
i₁ : I₁
i₂ : I₂
j : J
h : c₁.π c₂ c (i₁, i₂) = j
⊢ c₂.π c₁ c (i₂, i₁) = j
state_after: no goals
tactic: rw [ComplexShape.π_symm c₁ c₂ c i₁ i₂, h]
state_before: C : Type u_1
I₁ : Type u_2
I₂ : Type u_3
J : Type u_4
inst✝⁷ : Category.{u_5, u_1} C
inst✝⁶ : Preadditive C
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
c : ComplexShape J
inst✝⁵ : TotalComplexShape c₁ c₂ c
inst✝⁴ : TotalComplexShape c₂ c₁ c
inst✝³ : TotalComplexShapeSymmetry c₁ c₂ c
inst✝² : K.HasTotal c
inst✝¹ : K.flip.HasTotal c
inst✝ : DecidableEq J
i₁ : I₁
i₂ : I₂
j : J
h : c₁.π c₂ c (i₁, i₂) = j
⊢ K.ιTotal c i₁ i₂ j h ≫ (K.totalFlipIso c).inv.f j = c₁.σ c₂ c i₁ i₂ • K.flip.ιTotal c i₂ i₁ j ⋯
state_after: no goals
tactic: simp [totalFlipIso, totalFlipIsoX]
Theorem: Cardinal.one_lt_iff_nontrivial
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α✝ β α : Type u
⊢ 1 < #α ↔ Nontrivial α
state_after: no goals
tactic: rw [← not_le, le_one_iff_subsingleton, ← not_nontrivial_iff_subsingleton, Classical.not_not]
Theorem: CategoryTheory.IsUniversalColimit.whiskerEquivalence_iff
File: Mathlib/CategoryTheory/Limits/VanKampen.lean

Proof steps:
state_before: J : Type v'
inst✝⁴ : Category.{u', v'} J
C : Type u
inst✝³ : Category.{v, u} C
K✝ : Type u_1
inst✝² : Category.{?u.135421, u_1} K✝
D : Type u_2
inst✝¹ : Category.{?u.135428, u_2} D
K : Type u_3
inst✝ : Category.{u_4, u_3} K
e : J ≌ K
F : K ⥤ C
c : Cocone F
hc : IsUniversalColimit (Cocone.whisker e.functor c)
⊢ ∀ (j : K),
    ((Cocones.precompose (e.invFunIdAssoc F).inv).obj
                (Cocone.whisker e.symm.functor (Cocone.whisker e.functor c))).ι.app
          j ≫
        (Iso.refl
            ((Cocones.precompose (e.invFunIdAssoc F).inv).obj
                (Cocone.whisker e.symm.functor (Cocone.whisker e.functor c))).pt).hom =
      c.ι.app j
state_after: no goals
tactic: simp
Theorem: ZMod.pow_card_sub_one
File: Mathlib/FieldTheory/Finite/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
⊢ a ^ (p - 1) = if a ≠ 0 then 1 else 0
state_after: case pos
K : Type u_1
R : Type u_2
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
ha : a ≠ 0
⊢ a ^ (p - 1) = 1

case neg
K : Type u_1
R : Type u_2
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
ha : ¬a ≠ 0
⊢ a ^ (p - 1) = 0
tactic: split_ifs with ha
Theorem: Filter.prod_lift'_lift'
File: Mathlib/Order/Filter/Lift.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f : Filter α
α₁ : Type u_5
α₂ : Type u_6
β₁ : Type u_7
β₂ : Type u_8
f₁ : Filter α₁
f₂ : Filter α₂
g₁ : Set α₁ → Set β₁
g₂ : Set α₂ → Set β₂
hg₁ : Monotone g₁
hg₂ : Monotone g₂
⊢ (f₁.lift fun s => f₂.lift fun t => 𝓟 (g₁ s) ×ˢ 𝓟 (g₂ t)) = f₁.lift fun s => f₂.lift fun t => 𝓟 (g₁ s ×ˢ g₂ t)
state_after: no goals
tactic: simp only [prod_principal_principal]
Theorem: Filter.tendsto_const_mul_atTop_iff_neg
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : LinearOrderedField α
l : Filter β
f : β → α
r : α
inst✝ : l.NeBot
h : Tendsto f l atBot
⊢ Tendsto (fun x => r * f x) l atTop ↔ r < 0
state_after: no goals
tactic: simp [tendsto_const_mul_atTop_iff, h, h.not_tendsto disjoint_atBot_atTop]
Theorem: ContDiffBump.integral_normed
File: Mathlib/Analysis/Calculus/BumpFunction/Normed.lean

Proof steps:
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ ∫ (x : E), f.normed μ x ∂μ = 1
state_after: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ (∫ (x : E), ↑f x ∂μ)⁻¹ • ∫ (x : E), ↑f x ∂μ = 1
tactic: simp_rw [ContDiffBump.normed, div_eq_mul_inv, mul_comm (f _), ← smul_eq_mul, integral_smul]
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ (∫ (x : E), ↑f x ∂μ)⁻¹ • ∫ (x : E), ↑f x ∂μ = 1
state_after: no goals
tactic: exact inv_mul_cancel f.integral_pos.ne'
Theorem: Polynomial.degree_gcd_le_right
File: Mathlib/RingTheory/Polynomial/Content.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hq : q ≠ 0
⊢ (gcd p q).degree ≤ q.degree
state_after: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hq : q ≠ 0
⊢ (gcd q p).degree ≤ q.degree
tactic: rw [gcd_comm]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hq : q ≠ 0
⊢ (gcd q p).degree ≤ q.degree
state_after: no goals
tactic: exact degree_gcd_le_left hq p
Theorem: sbtw_vadd_const_iff
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : V
p : P
⊢ Sbtw R (x +ᵥ p) (y +ᵥ p) (z +ᵥ p) ↔ Sbtw R x y z
state_after: no goals
tactic: rw [Sbtw, Sbtw, wbtw_vadd_const_iff, (vadd_right_injective p).ne_iff,
    (vadd_right_injective p).ne_iff]
Theorem: Nat.pred_one_add
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
⊢ (1 + n).pred = n
state_after: no goals
tactic: rw [Nat.add_comm, add_one, Nat.pred_succ]
Theorem: LocalizedModule.zero_mk
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
s : ↥S
⊢ 1 • 1 • 0 = 1 • s • 0
state_after: no goals
tactic: rw [one_smul, smul_zero, smul_zero, one_smul]
Theorem: descPochhammer_natDegree
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

Proof steps:
state_before: R : Type u
inst✝² : Ring R
n : ℕ
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
⊢ (descPochhammer R n).natDegree = n
state_after: case zero
R : Type u
inst✝² : Ring R
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
⊢ (descPochhammer R 0).natDegree = 0

case succ
R : Type u
inst✝² : Ring R
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
n : ℕ
hn : (descPochhammer R n).natDegree = n
⊢ (descPochhammer R (n + 1)).natDegree = n + 1
tactic: induction' n with n hn
Theorem: CategoryTheory.MonoidalClosed.pre_comm_ihom_map
File: Mathlib/CategoryTheory/Closed/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
A B X✝ X' Y✝ Y' Z✝ : C
inst✝³ : Closed A
inst✝² : Closed B
W X Y Z : C
inst✝¹ : Closed W
inst✝ : Closed X
f : W ⟶ X
g : Y ⟶ Z
⊢ (pre f).app Y ≫ (ihom W).map g = (ihom X).map g ≫ (pre f).app Z
state_after: no goals
tactic: simp
Theorem: IsUpperSet.card_inter_le_finset
File: Mathlib/Combinatorics/SetFamily/HarrisKleitman.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜 : IsUpperSet ↑𝒜
hℬ : IsLowerSet ↑ℬ
⊢ 2 ^ Fintype.card α * (𝒜 ∩ ℬ).card ≤ 𝒜.card * ℬ.card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜 : IsLowerSet ↑𝒜ᶜ
hℬ : IsLowerSet ↑ℬ
⊢ 2 ^ Fintype.card α * (𝒜 ∩ ℬ).card ≤ 𝒜.card * ℬ.card
tactic: rw [← isLowerSet_compl, ← coe_compl] at h𝒜
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜 : IsLowerSet ↑𝒜ᶜ
hℬ : IsLowerSet ↑ℬ
⊢ 2 ^ Fintype.card α * (𝒜 ∩ ℬ).card ≤ 𝒜.card * ℬ.card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜 : IsLowerSet ↑𝒜ᶜ
hℬ : IsLowerSet ↑ℬ
this : 𝒜ᶜ.card * ℬ.card ≤ 2 ^ Fintype.card α * (𝒜ᶜ ∩ ℬ).card
⊢ 2 ^ Fintype.card α * (𝒜 ∩ ℬ).card ≤ 𝒜.card * ℬ.card
tactic: have := h𝒜.le_card_inter_finset hℬ
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜 : IsLowerSet ↑𝒜ᶜ
hℬ : IsLowerSet ↑ℬ
this : 𝒜ᶜ.card * ℬ.card ≤ 2 ^ Fintype.card α * (𝒜ᶜ ∩ ℬ).card
⊢ 2 ^ Fintype.card α * (𝒜 ∩ ℬ).card ≤ 𝒜.card * ℬ.card
state_after: no goals
tactic: rwa [card_compl, Fintype.card_finset, tsub_mul, tsub_le_iff_tsub_le, ← mul_tsub, ←
    card_sdiff inter_subset_right, sdiff_inter_self_right, sdiff_compl,
    _root_.inf_comm] at this
Theorem: Cardinal.aleph'_zero
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: ⊢ aleph' 0 = 0
state_after: ⊢ 0 ≤ alephIdx 0
tactic: rw [← nonpos_iff_eq_zero, ← aleph'_alephIdx 0, aleph'_le]
state_before: ⊢ 0 ≤ alephIdx 0
state_after: no goals
tactic: apply Ordinal.zero_le
Theorem: Batteries.TransCmp.cmp_congr_right
File: .lake/packages/batteries/Batteries/Classes/Order.lean

Proof steps:
state_before: cmp✝ : ?m.5873 → ?m.5873 → Ordering
inst✝¹ : TransCmp cmp✝
x✝ : Sort ?u.5871
cmp : x✝ → x✝ → Ordering
inst✝ : TransCmp cmp
y z x : x✝
yz : cmp y z = Ordering.eq
⊢ cmp x y = cmp x z
state_after: no goals
tactic: rw [← Ordering.swap_inj, symm, symm, cmp_congr_left yz]
Theorem: SetTheory.PGame.insertRight_equiv_of_lf
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x x' : PGame
h : x ⧏ x'
⊢ x.insertRight x' ≈ x
state_after: xl xr : Type u
x x' : PGame
h : x ⧏ x'
⊢ (-x).insertLeft (-x') ≈ -x
tactic: rw [← neg_equiv_neg_iff, ← neg_insertLeft_neg]
state_before: xl xr : Type u
x x' : PGame
h : x ⧏ x'
⊢ (-x).insertLeft (-x') ≈ -x
state_after: no goals
tactic: exact insertLeft_equiv_of_lf (neg_lf_neg_iff.mpr h)
Theorem: LinearMap.det_cases
File: Mathlib/LinearAlgebra/Determinant.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type u_3
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type u_6
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
P : A → Prop
f : M →ₗ[A] M
hb : ∀ (s : Finset M) (b : Basis { x // x ∈ s } A M), P ((toMatrix b b) f).det
h1 : P 1
⊢ P (LinearMap.det f)
state_after: R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type u_3
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type u_6
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
P : A → Prop
f : M →ₗ[A] M
hb : ∀ (s : Finset M) (b : Basis { x // x ∈ s } A M), P ((toMatrix b b) f).det
h1 : P 1
⊢ P ((if H : ∃ s, Nonempty (Basis { x // x ∈ s } A M) then detAux (Trunc.mk ⋯.some) else 1) f)
tactic: rw [LinearMap.det_def]
state_before: R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type u_3
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type u_6
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
P : A → Prop
f : M →ₗ[A] M
hb : ∀ (s : Finset M) (b : Basis { x // x ∈ s } A M), P ((toMatrix b b) f).det
h1 : P 1
⊢ P ((if H : ∃ s, Nonempty (Basis { x // x ∈ s } A M) then detAux (Trunc.mk ⋯.some) else 1) f)
state_after: case pos
R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type u_3
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type u_6
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
P : A → Prop
f : M →ₗ[A] M
hb : ∀ (s : Finset M) (b : Basis { x // x ∈ s } A M), P ((toMatrix b b) f).det
h1 : P 1
h : ∃ s, Nonempty (Basis { x // x ∈ s } A M)
⊢ P ((detAux (Trunc.mk ⋯.some)) f)

case neg
R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type u_3
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type u_6
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
P : A → Prop
f : M →ₗ[A] M
hb : ∀ (s : Finset M) (b : Basis { x // x ∈ s } A M), P ((toMatrix b b) f).det
h1 : P 1
h : ¬∃ s, Nonempty (Basis { x // x ∈ s } A M)
⊢ P (1 f)
tactic: split_ifs with h
Theorem: Invertible.congr
File: Mathlib/Algebra/Group/Invertible/Defs.lean

Proof steps:
state_before: α : Type u
inst✝² : Monoid α
a b : α
inst✝¹ : Invertible a
inst✝ : Invertible b
h : a = b
⊢ ⅟a = ⅟b
state_after: α : Type u
inst✝² : Monoid α
a : α
inst✝¹ inst✝ : Invertible a
⊢ ⅟a = ⅟a
tactic: subst h
state_before: α : Type u
inst✝² : Monoid α
a : α
inst✝¹ inst✝ : Invertible a
⊢ ⅟a = ⅟a
state_after: case h.e_5.h
α : Type u
inst✝² : Monoid α
a : α
inst✝¹ inst✝ : Invertible a
⊢ inst✝¹ = inst✝
tactic: congr
state_before: case h.e_5.h
α : Type u
inst✝² : Monoid α
a : α
inst✝¹ inst✝ : Invertible a
⊢ inst✝¹ = inst✝
state_after: no goals
tactic: apply Subsingleton.allEq
Theorem: Cardinal.ofENat_eq_lift
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: x : Cardinal.{v}
m : ℕ∞
⊢ ↑m = lift.{u, v} x ↔ ↑m = x
state_after: no goals
tactic: rw [← lift_ofENat.{u, v}, lift_inj]
Theorem: pow_orderOf_eq_one
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: case convert_2
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x✝ y : G
n m : ℕ
x : G
⊢ x ^ orderOf x = (fun x_1 => x * x_1)^[minimalPeriod (fun x_1 => x * x_1) 1] 1
state_after: case convert_2
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x✝ y : G
n m : ℕ
x : G
⊢ x ^ minimalPeriod (fun x_1 => x * x_1) 1 = (fun x_1 => x ^ minimalPeriod (fun x_2 => x * x_2) 1 * x_1) 1
tactic: rw [orderOf, mul_left_iterate]
state_before: case convert_2
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x✝ y : G
n m : ℕ
x : G
⊢ x ^ minimalPeriod (fun x_1 => x * x_1) 1 = (fun x_1 => x ^ minimalPeriod (fun x_2 => x * x_2) 1 * x_1) 1
state_after: case convert_2
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x✝ y : G
n m : ℕ
x : G
⊢ x ^ minimalPeriod (fun x_1 => x * x_1) 1 = x ^ minimalPeriod (fun x_1 => x * x_1) 1 * 1
tactic: beta_reduce
state_before: case convert_2
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x✝ y : G
n m : ℕ
x : G
⊢ x ^ minimalPeriod (fun x_1 => x * x_1) 1 = x ^ minimalPeriod (fun x_1 => x * x_1) 1 * 1
state_after: no goals
tactic: rw [mul_one]
Theorem: Submodule.restrictScalarsEmbedding_apply
File: Mathlib/Algebra/Module/Submodule/RestrictScalars.lean

Proof steps:
state_before: S : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Semiring S
inst✝³ : Module S M
inst✝² : Module R M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
⊢ ∀ {a b : Submodule R M},
    { toFun := restrictScalars S, inj' := ⋯ } a ≤ { toFun := restrictScalars S, inj' := ⋯ } b ↔ a ≤ b
state_after: no goals
tactic: simp [SetLike.le_def]
Theorem: PiTensorProduct.toDualContinuousMultilinearMap_le_projectiveSeminorm
File: Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean

Proof steps:
state_before: ι : Type uι
inst✝⁵ : Fintype ι
𝕜 : Type u𝕜
inst✝⁴ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
x : ⨂[𝕜] (i : ι), E i
⊢ ‖(toDualContinuousMultilinearMap F) x‖ ≤ projectiveSeminorm x
state_after: ι : Type uι
inst✝⁵ : Fintype ι
𝕜 : Type u𝕜
inst✝⁴ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
x : ⨂[𝕜] (i : ι), E i
⊢ ‖((↑lift).flip x ∘ₗ ContinuousMultilinearMap.toMultilinearMapLinear).mkContinuous (projectiveSeminorm x) ⋯‖ ≤
    projectiveSeminorm x
tactic: simp only [toDualContinuousMultilinearMap, LinearMap.coe_mk, AddHom.coe_mk]
state_before: ι : Type uι
inst✝⁵ : Fintype ι
𝕜 : Type u𝕜
inst✝⁴ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝³ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝¹ : SeminormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
x : ⨂[𝕜] (i : ι), E i
⊢ ‖((↑lift).flip x ∘ₗ ContinuousMultilinearMap.toMultilinearMapLinear).mkContinuous (projectiveSeminorm x) ⋯‖ ≤
    projectiveSeminorm x
state_after: no goals
tactic: apply LinearMap.mkContinuous_norm_le _ (apply_nonneg _ _)
Theorem: Set.ncard_insert_le
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
a : α
s : Set α
⊢ (insert a s).ncard ≤ s.ncard + 1
state_after: case inl
α : Type u_1
β : Type u_2
s✝ t : Set α
a : α
s : Set α
hs : s.Finite
⊢ (insert a s).ncard ≤ s.ncard + 1

case inr
α : Type u_1
β : Type u_2
s✝ t : Set α
a : α
s : Set α
hs : s.Infinite
⊢ (insert a s).ncard ≤ s.ncard + 1
tactic: obtain hs | hs := s.finite_or_infinite
state_before: case inr
α : Type u_1
β : Type u_2
s✝ t : Set α
a : α
s : Set α
hs : s.Infinite
⊢ (insert a s).ncard ≤ s.ncard + 1
state_after: case inr
α : Type u_1
β : Type u_2
s✝ t : Set α
a : α
s : Set α
hs : s.Infinite
⊢ 0 ≤ s.ncard + 1
tactic: rw [(hs.mono (subset_insert a s)).ncard]
state_before: case inr
α : Type u_1
β : Type u_2
s✝ t : Set α
a : α
s : Set α
hs : s.Infinite
⊢ 0 ≤ s.ncard + 1
state_after: no goals
tactic: exact Nat.zero_le _
Theorem: List.next_prev
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
h : l.Nodup
x : α
hx : x ∈ l
⊢ l.next (l.prev x hx) ⋯ = x
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
n : ℕ
hn : n < l.length
hx : l.nthLe n hn ∈ l
⊢ l.next (l.prev (l.nthLe n hn) hx) ⋯ = l.nthLe n hn
tactic: obtain ⟨n, hn, rfl⟩ := nthLe_of_mem hx
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
n : ℕ
hn : n < l.length
hx : l.nthLe n hn ∈ l
⊢ l.next (l.prev (l.nthLe n hn) hx) ⋯ = l.nthLe n hn
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
n : ℕ
hn : n < l.length
hx : l.nthLe n hn ∈ l
⊢ l.nthLe ((n + (l.length - 1) + 1) % l.length) ⋯ = l.nthLe n hn
tactic: simp only [next_nthLe, prev_nthLe, h, Nat.mod_add_mod]
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
n : ℕ
hn : n < l.length
hx : l.nthLe n hn ∈ l
⊢ l.nthLe ((n + (l.length - 1) + 1) % l.length) ⋯ = l.nthLe n hn
state_after: case intro.intro.nil
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
n : ℕ
h : [].Nodup
hn : n < [].length
hx : [].nthLe n hn ∈ []
⊢ [].nthLe ((n + ([].length - 1) + 1) % [].length) ⋯ = [].nthLe n hn

case intro.intro.cons
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
n : ℕ
hd : α
tl : List α
h : (hd :: tl).Nodup
hn : n < (hd :: tl).length
hx : (hd :: tl).nthLe n hn ∈ hd :: tl
⊢ (hd :: tl).nthLe ((n + ((hd :: tl).length - 1) + 1) % (hd :: tl).length) ⋯ = (hd :: tl).nthLe n hn
tactic: cases' l with hd tl
Theorem: LinearOrderedField.smul_Ioc
File: Mathlib/Algebra/Order/Pointwise.lean

Proof steps:
state_before: α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
⊢ r • Ioc a b = Ioc (r • a) (r • b)
state_after: case h
α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ x ∈ r • Ioc a b ↔ x ∈ Ioc (r • a) (r • b)
tactic: ext x
state_before: case h
α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ x ∈ r • Ioc a b ↔ x ∈ Ioc (r • a) (r • b)
state_after: case h
α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ (∃ y, (a < y ∧ y ≤ b) ∧ r * y = x) ↔ r * a < x ∧ x ≤ r * b
tactic: simp only [mem_smul_set, smul_eq_mul, mem_Ioc]
state_before: case h
α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ (∃ y, (a < y ∧ y ≤ b) ∧ r * y = x) ↔ r * a < x ∧ x ≤ r * b
state_after: case h.mp
α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ (∃ y, (a < y ∧ y ≤ b) ∧ r * y = x) → r * a < x ∧ x ≤ r * b

case h.mpr
α : Type u_1
K : Type u_2
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ r * a < x ∧ x ≤ r * b → ∃ y, (a < y ∧ y ≤ b) ∧ r * y = x
tactic: constructor
Theorem: Int.ModEq.add_right_cancel
File: Mathlib/Data/Int/ModEq.lean

Proof steps:
state_before: m n a b c d : ℤ
h₁ : c ≡ d [ZMOD n]
h₂ : a + c ≡ b + d [ZMOD n]
⊢ a ≡ b [ZMOD n]
state_after: m n a b c d : ℤ
h₁ : c ≡ d [ZMOD n]
h₂ : c + a ≡ d + b [ZMOD n]
⊢ a ≡ b [ZMOD n]
tactic: rw [add_comm a, add_comm b] at h₂
state_before: m n a b c d : ℤ
h₁ : c ≡ d [ZMOD n]
h₂ : c + a ≡ d + b [ZMOD n]
⊢ a ≡ b [ZMOD n]
state_after: no goals
tactic: exact h₁.add_left_cancel h₂
Theorem: PresheafOfModules.restrictionApp_apply
File: Mathlib/Algebra/Category/ModuleCat/Presheaf.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
R : Cᵒᵖ ⥤ RingCat
X Y : Cᵒᵖ
f : X ⟶ Y
M : PresheafOfModules R
x : ↑(M.obj X)
⊢ (restrictionApp f M) x = (M.map f) x
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Presieve.isSheafFor_subsieve
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S✝ : Sieve X
R✝ : Presieve X
P : Cᵒᵖ ⥤ Type w
S : Sieve X
R : Presieve X
h : S.arrows ≤ R
trans : ∀ ⦃Y : C⦄ (f : Y ⟶ X), IsSheafFor P (Sieve.pullback f S).arrows
⊢ IsSheafFor P S.arrows
state_after: no goals
tactic: simpa using trans (𝟙 _)