ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: FirstOrder.Language.Term.constantsVarsEquiv_symm_apply
File: Mathlib/ModelTheory/Syntax.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
⊢ Function.LeftInverse varsToConstants constantsToVars
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
t : L[[γ]].Term α
⊢ t.constantsToVars.varsToConstants = t
tactic: intro t
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
t : L[[γ]].Term α
⊢ t.constantsToVars.varsToConstants = t
state_after: case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
a✝ : α
⊢ (var a✝).constantsToVars.varsToConstants = var a✝

case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
f : L[[γ]].Functions n
_ts✝ : Fin n → L[[γ]].Term α
ih : ∀ (a : Fin n), (_ts✝ a).constantsToVars.varsToConstants = _ts✝ a
⊢ (func f _ts✝).constantsToVars.varsToConstants = func f _ts✝
tactic: induction' t with _ n f _ ih
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
⊢ Function.RightInverse varsToConstants constantsToVars
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
t : L.Term (γ ⊕ α)
⊢ t.varsToConstants.constantsToVars = t
tactic: intro t
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
t : L.Term (γ ⊕ α)
⊢ t.varsToConstants.constantsToVars = t
state_after: case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
x : γ ⊕ α
⊢ (var x).varsToConstants.constantsToVars = var x

case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
f : L.Functions n
_ts✝ : Fin n → L.Term (γ ⊕ α)
ih : ∀ (a : Fin n), (_ts✝ a).varsToConstants.constantsToVars = _ts✝ a
⊢ (func f _ts✝).varsToConstants.constantsToVars = func f _ts✝
tactic: induction' t with x n f _ ih
Theorem: PartENat.toWithTop_le
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: x y : PartENat
hx : Decidable x.Dom
hy : Decidable y.Dom
⊢ x.toWithTop ≤ y.toWithTop ↔ x ≤ y
state_after: case a
x : PartENat
hx : Decidable x.Dom
hy : Decidable ⊤.Dom
⊢ x.toWithTop ≤ ⊤.toWithTop ↔ x ≤ ⊤

case a
x : PartENat
hx : Decidable x.Dom
n✝ : ℕ
hy : Decidable (↑n✝).Dom
⊢ x.toWithTop ≤ (↑n✝).toWithTop ↔ x ≤ ↑n✝
tactic: induction y using PartENat.casesOn generalizing hy
state_before: case a
x : PartENat
hx : Decidable x.Dom
n✝ : ℕ
hy : Decidable (↑n✝).Dom
⊢ x.toWithTop ≤ (↑n✝).toWithTop ↔ x ≤ ↑n✝
state_after: case a.a
n✝ : ℕ
hy : Decidable (↑n✝).Dom
hx : Decidable ⊤.Dom
⊢ ⊤.toWithTop ≤ (↑n✝).toWithTop ↔ ⊤ ≤ ↑n✝

case a.a
n✝¹ : ℕ
hy : Decidable (↑n✝¹).Dom
n✝ : ℕ
hx : Decidable (↑n✝).Dom
⊢ (↑n✝).toWithTop ≤ (↑n✝¹).toWithTop ↔ ↑n✝ ≤ ↑n✝¹
tactic: induction x using PartENat.casesOn generalizing hx
Theorem: SetTheory.PGame.birthday_moveRight_lt
File: Mathlib/SetTheory/Game/Birthday.lean

Proof steps:
state_before: x : PGame
i : x.RightMoves
⊢ (x.moveRight i).birthday < x.birthday
state_after: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ ((mk α✝ β✝ a✝¹ a✝).moveRight i).birthday < (mk α✝ β✝ a✝¹ a✝).birthday
tactic: cases x
state_before: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ ((mk α✝ β✝ a✝¹ a✝).moveRight i).birthday < (mk α✝ β✝ a✝¹ a✝).birthday
state_after: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ ((mk α✝ β✝ a✝¹ a✝).moveRight i).birthday < max (lsub fun i => (a✝¹ i).birthday) (lsub fun i => (a✝ i).birthday)
tactic: rw [birthday]
state_before: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ ((mk α✝ β✝ a✝¹ a✝).moveRight i).birthday < max (lsub fun i => (a✝¹ i).birthday) (lsub fun i => (a✝ i).birthday)
state_after: no goals
tactic: exact lt_max_of_lt_right (lt_lsub _ i)
Theorem: intervalIntegrable_sub_inv_iff
File: Mathlib/Analysis/SpecialFunctions/NonIntegrable.lean

Proof steps:
state_before: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a b c : ℝ
⊢ IntervalIntegrable (fun x => (x - c)⁻¹) volume a b ↔ a = b ∨ c ∉ [[a, b]]
state_after: case mp
E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a b c : ℝ
⊢ IntervalIntegrable (fun x => (x - c)⁻¹) volume a b → a = b ∨ c ∉ [[a, b]]

case mpr
E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a b c : ℝ
⊢ a = b ∨ c ∉ [[a, b]] → IntervalIntegrable (fun x => (x - c)⁻¹) volume a b
tactic: constructor
Theorem: RingHom.FinitePresentation.of_surjective
File: Mathlib/RingTheory/FinitePresentation.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
hf : Surjective ⇑f
hker : (ker f).FG
⊢ f.FinitePresentation
state_after: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
hf : Surjective ⇑f
hker : (ker f).FG
⊢ (f.comp (RingHom.id A)).FinitePresentation
tactic: rw [← f.comp_id]
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
hf : Surjective ⇑f
hker : (ker f).FG
⊢ (f.comp (RingHom.id A)).FinitePresentation
state_after: no goals
tactic: exact (id A).comp_surjective hf hker
Theorem: LieSubmodule.isNilpotent_iff_exists_self_le_ucs
File: Mathlib/Algebra/Lie/Nilpotent.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
k : ℕ
N N₁ N₂ : LieSubmodule R L M
⊢ LieModule.IsNilpotent R L ↥↑N ↔ ∃ k, N ≤ ucs k ⊥
state_after: no goals
tactic: simp_rw [LieModule.isNilpotent_iff_exists_ucs_eq_top, ← ucs_comap_incl, comap_incl_eq_top]
Theorem: Nat.not_dvd_ord_compl
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m n✝ p✝ n p : ℕ
hp : Prime p
hn : n ≠ 0
⊢ ¬p ∣ n / p ^ n.factorization p
state_after: a b m n✝ p✝ n p : ℕ
hp : Prime p
hn : n ≠ 0
⊢ ¬1 ≤ (n / p ^ n.factorization p).factorization p
tactic: rw [Nat.Prime.dvd_iff_one_le_factorization hp (ord_compl_pos p hn).ne']
state_before: a b m n✝ p✝ n p : ℕ
hp : Prime p
hn : n ≠ 0
⊢ ¬1 ≤ (n / p ^ n.factorization p).factorization p
state_after: a b m n✝ p✝ n p : ℕ
hp : Prime p
hn : n ≠ 0
⊢ ¬1 ≤ (n.factorization - (p ^ n.factorization p).factorization) p
tactic: rw [Nat.factorization_div (Nat.ord_proj_dvd n p)]
state_before: a b m n✝ p✝ n p : ℕ
hp : Prime p
hn : n ≠ 0
⊢ ¬1 ≤ (n.factorization - (p ^ n.factorization p).factorization) p
state_after: no goals
tactic: simp [hp.factorization]
Theorem: AddSubgroup.mem_sSup_of_directedOn
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K✝ : Subgroup G
k : Set G
K : Set (Subgroup G)
Kne : K.Nonempty
hK : DirectedOn (fun x x_1 => x ≤ x_1) K
x : G
⊢ x ∈ sSup K ↔ ∃ s ∈ K, x ∈ s
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K✝ : Subgroup G
k : Set G
K : Set (Subgroup G)
Kne : K.Nonempty
hK : DirectedOn (fun x x_1 => x ≤ x_1) K
x : G
this : Nonempty ↑K
⊢ x ∈ sSup K ↔ ∃ s ∈ K, x ∈ s
tactic: haveI : Nonempty K := Kne.to_subtype
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K✝ : Subgroup G
k : Set G
K : Set (Subgroup G)
Kne : K.Nonempty
hK : DirectedOn (fun x x_1 => x ≤ x_1) K
x : G
this : Nonempty ↑K
⊢ x ∈ sSup K ↔ ∃ s ∈ K, x ∈ s
state_after: no goals
tactic: simp only [sSup_eq_iSup', mem_iSup_of_directed hK.directed_val, SetCoe.exists, Subtype.coe_mk,
    exists_prop]
Theorem: MvPolynomial.weightedTotalDegree_zero
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝³ : CommSemiring R
σ : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : SemilatticeSup M
inst✝ : OrderBot M
w : σ → M
⊢ weightedTotalDegree w 0 = ⊥
state_after: no goals
tactic: simp only [weightedTotalDegree, support_zero, Finset.sup_empty]
Theorem: Set.mulIndicator_inter_mulSupport
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f✝ g : α → M
a : α
s : Set α
f : α → M
⊢ (s ∩ mulSupport f).mulIndicator f = s.mulIndicator f
state_after: no goals
tactic: rw [← mulIndicator_mulIndicator, mulIndicator_mulSupport]
Theorem: Real.Angle.coe_abs_toReal_of_sign_nonneg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
h : 0 ≤ θ.sign
⊢ ↑|θ.toReal| = θ
state_after: no goals
tactic: rw [abs_eq_self.2 (toReal_nonneg_iff_sign_nonneg.2 h), coe_toReal]
Theorem: Dense.diff_finset
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : T1Space X
inst✝ : ∀ (x : X), (𝓝[≠] x).NeBot
s : Set X
hs : Dense s
t : Finset X
⊢ Dense (s \ ↑t)
state_after: no goals
tactic: induction t using Finset.induction_on with
  | empty => simpa using hs
  | insert _ ih =>
    rw [Finset.coe_insert, ← union_singleton, ← diff_diff]
    exact ih.diff_singleton _
Theorem: SetTheory.PGame.moveLeft_nim_hEq
File: Mathlib/SetTheory/Game/Nim.lean

Proof steps:
state_before: o : Ordinal.{u_1}
⊢ let_fun this := ⋯;
  HEq (nim o).moveLeft fun i => nim (typein (fun x x_1 => x < x_1) i)
state_after: o : Ordinal.{u_1}
⊢ let_fun this := ⋯;
  HEq
    (mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
        nim (typein (fun x x_1 => x < x_1) o₂)).moveLeft
    fun i => nim (typein (fun x x_1 => x < x_1) i)
tactic: rw [nim_def]
state_before: o : Ordinal.{u_1}
⊢ let_fun this := ⋯;
  HEq
    (mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
        nim (typein (fun x x_1 => x < x_1) o₂)).moveLeft
    fun i => nim (typein (fun x x_1 => x < x_1) i)
state_after: no goals
tactic: rfl
Theorem: ZNum.zneg_pred
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
n : ZNum
⊢ -n.pred = (-n).succ
state_after: no goals
tactic: rw [← zneg_zneg (succ (-n)), zneg_succ, zneg_zneg]
Theorem: Submodule.rank_le_one_iff_isPrincipal
File: Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W : Submodule K V
inst✝ : Module.Free K ↥W
⊢ Module.rank K ↥W ≤ 1 ↔ W.IsPrincipal
state_after: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W : Submodule K V
inst✝ : Module.Free K ↥W
⊢ (∃ v₀, ∀ (v : ↥W), ∃ r, r • v₀ = v) ↔ ∃ a, (∀ v ∈ W, ∃ r, r • a = v) ∧ a ∈ W
tactic: simp only [rank_le_one_iff, Submodule.isPrincipal_iff, le_antisymm_iff, le_span_singleton_iff,
    span_singleton_le_iff_mem]
state_before: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W : Submodule K V
inst✝ : Module.Free K ↥W
⊢ (∃ v₀, ∀ (v : ↥W), ∃ r, r • v₀ = v) ↔ ∃ a, (∀ v ∈ W, ∃ r, r • a = v) ∧ a ∈ W
state_after: case mp
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W : Submodule K V
inst✝ : Module.Free K ↥W
⊢ (∃ v₀, ∀ (v : ↥W), ∃ r, r • v₀ = v) → ∃ a, (∀ v ∈ W, ∃ r, r • a = v) ∧ a ∈ W

case mpr
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W : Submodule K V
inst✝ : Module.Free K ↥W
⊢ (∃ a, (∀ v ∈ W, ∃ r, r • a = v) ∧ a ∈ W) → ∃ v₀, ∀ (v : ↥W), ∃ r, r • v₀ = v
tactic: constructor
Theorem: CategoryTheory.Idempotents.Karoubi.id_eq
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.14791, u_1} C
P : Karoubi C
⊢ P.p = P.p ≫ P.p ≫ P.p
state_after: no goals
tactic: repeat' rw [P.idem]
Theorem: CategoryTheory.ComposableArrows.mk₂_surjective
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : ComposableArrows C 2
⊢ X.map' 0 1 ⋯ ⋯ = eqToHom ⋯ ≫ (mk₂ (X.map' 0 1 ⋯ ⋯) (X.map' 1 2 ⋯ ⋯)).map' 0 1 ⋯ ⋯ ≫ eqToHom ⋯
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : ComposableArrows C 2
⊢ X.map' 1 2 ⋯ ⋯ = eqToHom ⋯ ≫ (mk₂ (X.map' 0 1 ⋯ ⋯) (X.map' 1 2 ⋯ ⋯)).map' 1 2 ⋯ ⋯ ≫ eqToHom ⋯
state_after: no goals
tactic: simp
Theorem: MeasureTheory.MeasurePreserving.lintegral_comp
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν✝ : Measure α
mb : MeasurableSpace β
ν : Measure β
g : α → β
hg : MeasurePreserving g μ ν
f : β → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (a : α), f (g a) ∂μ = ∫⁻ (b : β), f b ∂ν
state_after: no goals
tactic: rw [← hg.map_eq, lintegral_map hf hg.measurable]
Theorem: CategoryTheory.Bicategory.whiskerLeft_rightUnitor
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ f ◁ (ρ_ g).hom = (α_ f g (𝟙 c)).inv ≫ (ρ_ (f ≫ g)).hom
state_after: no goals
tactic: rw [← whiskerRight_iff, comp_whiskerRight, ← cancel_epi (α_ _ _ _).inv, ←
      cancel_epi (f ◁ (α_ _ _ _).inv), pentagon_inv_assoc, triangle_assoc_comp_right, ←
      associator_inv_naturality_middle, ← whiskerLeft_comp_assoc, triangle_assoc_comp_right,
      associator_inv_naturality_right]
Theorem: List.concat_perm
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
l : List α
a : α
⊢ l.concat a ~ a :: l
state_after: no goals
tactic: simp
Theorem: Subgroup.IsComplement.rightCosetEquivalence_equiv_snd
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
⊢ RightCosetEquivalence (↑H) g ↑(hHT.equiv g).2
state_after: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
⊢ (↑(hHT.equiv g).1)⁻¹ * g * g⁻¹ ∈ H
tactic: rw [RightCosetEquivalence, rightCoset_eq_iff, equiv_snd_eq_inv_mul]
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
⊢ (↑(hHT.equiv g).1)⁻¹ * g * g⁻¹ ∈ H
state_after: no goals
tactic: simp
Theorem: not_isRightRegular_zero_iff
File: Mathlib/Algebra/Regular/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ ¬IsRightRegular 0 ↔ Nontrivial R
state_after: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ (¬∃ x y, x ≠ y) ↔ ∀ (x y : R), x = y
tactic: rw [nontrivial_iff, not_iff_comm, isRightRegular_zero_iff_subsingleton, subsingleton_iff]
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ (¬∃ x y, x ≠ y) ↔ ∀ (x y : R), x = y
state_after: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ (∀ (x y : R), x = y) ↔ ∀ (x y : R), x = y
tactic: push_neg
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
⊢ (∀ (x y : R), x = y) ↔ ∀ (x y : R), x = y
state_after: no goals
tactic: exact Iff.rfl
Theorem: EisensteinSeries.r_mul_max_le
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean

Proof steps:
state_before: z : ℍ
x : Fin 2 → ℤ
hx : x ≠ 0
⊢ r z * ‖x‖ ≤ Complex.abs (↑(x 0) * ↑z + ↑(x 1))
state_after: z : ℍ
x : Fin 2 → ℤ
hx : x ≠ 0
hn0 : ‖x‖ ≠ 0
⊢ r z * ‖x‖ ≤ Complex.abs (↑(x 0) * ↑z + ↑(x 1))
tactic: have hn0 : ‖x‖ ≠ 0 := by rwa [norm_ne_zero_iff]
state_before: z : ℍ
x : Fin 2 → ℤ
hx : x ≠ 0
hn0 : ‖x‖ ≠ 0
⊢ r z * ‖x‖ ≤ Complex.abs (↑(x 0) * ↑z + ↑(x 1))
state_after: z : ℍ
x : Fin 2 → ℤ
hx : x ≠ 0
hn0 : ‖x‖ ≠ 0
h11 : ↑(x 0) * ↑z + ↑(x 1) = (↑(x 0) / ↑‖x‖ * ↑z + ↑(x 1) / ↑‖x‖) * ↑‖x‖
⊢ r z * ‖x‖ ≤ Complex.abs (↑(x 0) * ↑z + ↑(x 1))
tactic: have h11 : x 0 * (z : ℂ) + x 1 = (x 0 / ‖x‖ * z + x 1 / ‖x‖) * ‖x‖ := by
    rw [div_mul_eq_mul_div, ← add_div, div_mul_cancel₀ _ (mod_cast hn0)]
state_before: z : ℍ
x : Fin 2 → ℤ
hx : x ≠ 0
hn0 : ‖x‖ ≠ 0
h11 : ↑(x 0) * ↑z + ↑(x 1) = (↑(x 0) / ↑‖x‖ * ↑z + ↑(x 1) / ↑‖x‖) * ↑‖x‖
⊢ r z * ‖x‖ ≤ Complex.abs (↑(x 0) * ↑z + ↑(x 1))
state_after: z : ℍ
x : Fin 2 → ℤ
hx : x ≠ 0
hn0 : ‖x‖ ≠ 0
h11 : ↑(x 0) * ↑z + ↑(x 1) = (↑(x 0) / ↑‖x‖ * ↑z + ↑(x 1) / ↑‖x‖) * ↑‖x‖
⊢ r z * ↑(max (x 0).natAbs (x 1).natAbs) ≤
    Complex.abs (↑(x 0) / ↑↑(max (x 0).natAbs (x 1).natAbs) * ↑z + ↑(x 1) / ↑↑(max (x 0).natAbs (x 1).natAbs)) *
      ↑(max (x 0).natAbs (x 1).natAbs)
tactic: rw [norm_eq_max_natAbs, h11, map_mul, Complex.abs_ofReal, abs_norm, norm_eq_max_natAbs]
state_before: z : ℍ
x : Fin 2 → ℤ
hx : x ≠ 0
hn0 : ‖x‖ ≠ 0
h11 : ↑(x 0) * ↑z + ↑(x 1) = (↑(x 0) / ↑‖x‖ * ↑z + ↑(x 1) / ↑‖x‖) * ↑‖x‖
⊢ r z * ↑(max (x 0).natAbs (x 1).natAbs) ≤
    Complex.abs (↑(x 0) / ↑↑(max (x 0).natAbs (x 1).natAbs) * ↑z + ↑(x 1) / ↑↑(max (x 0).natAbs (x 1).natAbs)) *
      ↑(max (x 0).natAbs (x 1).natAbs)
state_after: case h
z : ℍ
x : Fin 2 → ℤ
hx : x ≠ 0
hn0 : ‖x‖ ≠ 0
h11 : ↑(x 0) * ↑z + ↑(x 1) = (↑(x 0) / ↑‖x‖ * ↑z + ↑(x 1) / ↑‖x‖) * ↑‖x‖
⊢ r z ≤ Complex.abs (↑(x 0) / ↑↑(max (x 0).natAbs (x 1).natAbs) * ↑z + ↑(x 1) / ↑↑(max (x 0).natAbs (x 1).natAbs))
tactic: gcongr
Theorem: Finset.single_lt_sum
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
i j : ι
hij : j ≠ i
hi : i ∈ s
hj : j ∈ s
hlt : 1 < f j
hle : ∀ k ∈ s, k ≠ i → 1 ≤ f k
⊢ f i = ∏ k ∈ {i}, f k
state_after: no goals
tactic: rw [prod_singleton]
Theorem: CategoryTheory.IsSplitEqualizer.map_leftRetraction
File: Mathlib/CategoryTheory/Limits/Shapes/SplitEqualizer.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
X Y : C
f g : X ⟶ Y
W : C
ι : W ⟶ X
q : IsSplitEqualizer f g ι
F : C ⥤ D
⊢ F.map ι ≫ F.map f = F.map ι ≫ F.map g
state_after: no goals
tactic: rw [← F.map_comp, q.condition, F.map_comp]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
X Y : C
f g : X ⟶ Y
W : C
ι : W ⟶ X
q : IsSplitEqualizer f g ι
F : C ⥤ D
⊢ F.map ι ≫ F.map q.leftRetraction = 𝟙 (F.obj W)
state_after: no goals
tactic: rw [← F.map_comp, q.ι_leftRetraction, F.map_id]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
X Y : C
f g : X ⟶ Y
W : C
ι : W ⟶ X
q : IsSplitEqualizer f g ι
F : C ⥤ D
⊢ F.map g ≫ F.map q.rightRetraction = 𝟙 (F.obj X)
state_after: no goals
tactic: rw [← F.map_comp, q.bottom_rightRetraction, F.map_id]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
X Y : C
f g : X ⟶ Y
W : C
ι : W ⟶ X
q : IsSplitEqualizer f g ι
F : C ⥤ D
⊢ F.map f ≫ F.map q.rightRetraction = F.map q.leftRetraction ≫ F.map ι
state_after: no goals
tactic: rw [← F.map_comp, q.top_rightRetraction, F.map_comp]
Theorem: finsum_mem_eq_of_bijOn
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g✝ : α → M
a b : α
s✝ t✝ s : Set α
t : Set β
f : α → M
g : β → M
e : α → β
he₀ : BijOn e s t
he₁ : ∀ x ∈ s, f x = g (e x)
⊢ ∏ᶠ (i : α) (_ : i ∈ s), f i = ∏ᶠ (j : β) (_ : j ∈ t), g j
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g✝ : α → M
a b : α
s✝ t✝ s : Set α
t : Set β
f : α → M
g : β → M
e : α → β
he₀ : BijOn e s t
he₁ : ∀ x ∈ s, f x = g (e x)
⊢ ∏ᶠ (i : α) (_ : i ∈ s), f i = ∏ᶠ (j : α) (_ : j ∈ s), g (e j)
tactic: rw [← Set.BijOn.image_eq he₀, finprod_mem_image he₀.2.1]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g✝ : α → M
a b : α
s✝ t✝ s : Set α
t : Set β
f : α → M
g : β → M
e : α → β
he₀ : BijOn e s t
he₁ : ∀ x ∈ s, f x = g (e x)
⊢ ∏ᶠ (i : α) (_ : i ∈ s), f i = ∏ᶠ (j : α) (_ : j ∈ s), g (e j)
state_after: no goals
tactic: exact finprod_mem_congr rfl he₁
Theorem: ContinuousMultilinearMap.mkPiRing_eq_zero_iff
File: Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean

Proof steps:
state_before: R : Type u
ι : Type v
n : ℕ
M✝ : Fin n.succ → Type w
M₁ : ι → Type w₁
M₁' : ι → Type w₁'
M₂ : Type w₂
M₃ : Type w₃
M₄ : Type w₄
M : Type u_1
inst✝⁷ : Fintype ι
inst✝⁶ : CommRing R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : TopologicalSpace R
inst✝² : TopologicalSpace M
inst✝¹ : ContinuousMul R
inst✝ : ContinuousSMul R M
z : M
⊢ ContinuousMultilinearMap.mkPiRing R ι z = 0 ↔ z = 0
state_after: no goals
tactic: rw [← mkPiRing_zero, mkPiRing_eq_iff]
Theorem: CharZero.charZero_iff_forall_prime_ne_zero
File: Mathlib/Algebra/CharP/Defs.lean

Proof steps:
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
⊢ CharZero R ↔ ∀ (p : ℕ), Nat.Prime p → ↑p ≠ 0
state_after: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
h : ∀ (p : ℕ), Nat.Prime p → ↑p ≠ 0
⊢ CharZero R
tactic: refine ⟨fun h p hp => by simp [hp.ne_zero], fun h => ?_⟩
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
h : ∀ (p : ℕ), Nat.Prime p → ↑p ≠ 0
⊢ CharZero R
state_after: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
h : ∀ (p : ℕ), Nat.Prime p → ↑p ≠ 0
p : ℕ := ringChar R
⊢ CharZero R
tactic: let p := ringChar R
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
h : ∀ (p : ℕ), Nat.Prime p → ↑p ≠ 0
p : ℕ := ringChar R
⊢ CharZero R
state_after: no goals
tactic: cases CharP.char_is_prime_or_zero R p with
  | inl hp => simpa using h p hp
  | inr h => have : CharP R 0 := h ▸ inferInstance; exact CharP.charP_to_charZero R