1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsAdjoinRootMonic.map_modByMonic
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: rw [← RingHom.sub_mem_ker_iff, mem_ker_map, modByMonic_eq_sub_mul_div _ h.Monic, sub_right_comm,
  sub_self, zero_sub, dvd_neg]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : R[X]
⊢ h.map (g %ₘ f) = h.map g
state_after: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : R[X]
⊢ f ∣ f * (g /ₘ f)

tactic: exact ⟨_, rfl⟩
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
g : R[X]
⊢ f ∣ f * (g /ₘ f)
state_after: no goals
Theorem: one_div_lt_of_neg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simpa using inv_lt_of_neg ha hb
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
ha : a < 0
hb : b < 0
⊢ 1 / a < b ↔ 1 / b < a
state_after: no goals
Theorem: Sigma.uncurry_mulSingle_mulSingle
File: Mathlib/Algebra/Group/Pi/Lemmas.lean

tactic: rw [← curry_mulSingle ⟨a, b⟩, uncurry_curry]
state_before: ι : Type u_1
α✝ : Type u_2
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i j : I
α : Type u_3
β : α → Type u_4
γ : (a : α) → β a → Type u_5
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (β a)
inst✝ : (a : α) → (b : β a) → One (γ a b)
a : α
b : β a
x : γ a b
⊢ uncurry (Pi.mulSingle a (Pi.mulSingle b x)) = Pi.mulSingle ⟨a, b⟩ x
state_after: no goals
Theorem: PadicSeq.lift_index_left
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: apply stationaryPoint_spec hf
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v3 : ℕ
⊢ padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑f (max v1 (max (stationaryPoint hf) v3)))
state_after: case a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v3 : ℕ
⊢ stationaryPoint hf ≤ max v1 (max (stationaryPoint hf) v3)

case a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v3 : ℕ
⊢ stationaryPoint hf ≤ stationaryPoint hf

tactic: apply le_trans
state_before: case a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v3 : ℕ
⊢ stationaryPoint hf ≤ max v1 (max (stationaryPoint hf) v3)
state_after: case a.a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v3 : ℕ
⊢ stationaryPoint hf ≤ ?a.b✝

case a.a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v3 : ℕ
⊢ ?a.b✝ ≤ max v1 (max (stationaryPoint hf) v3)

case a.b
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v3 : ℕ
⊢ ℕ

tactic: apply le_max_left _ v3
state_before: case a.a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v3 : ℕ
⊢ stationaryPoint hf ≤ ?a.b✝
state_after: no goals

tactic: apply le_max_right
state_before: case a.a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v3 : ℕ
⊢ max (stationaryPoint hf) v3 ≤ max v1 (max (stationaryPoint hf) v3)
state_after: no goals

tactic: exact le_rfl
state_before: case a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v3 : ℕ
⊢ stationaryPoint hf ≤ stationaryPoint hf
state_after: no goals
Theorem: CategoryTheory.Center.ext
File: Mathlib/CategoryTheory/Monoidal/Center.lean

tactic: cases f
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
f g : X ⟶ Y
w : f.f = g.f
⊢ f = g
state_after: case mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
g : X ⟶ Y
f✝ : X.fst ⟶ Y.fst
comm✝ : ∀ (U : C), f✝ ▷ U ≫ (Y.snd.β U).hom = (X.snd.β U).hom ≫ U ◁ f✝
w : { f := f✝, comm := comm✝ }.f = g.f
⊢ { f := f✝, comm := comm✝ } = g

tactic: cases g
state_before: case mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
g : X ⟶ Y
f✝ : X.fst ⟶ Y.fst
comm✝ : ∀ (U : C), f✝ ▷ U ≫ (Y.snd.β U).hom = (X.snd.β U).hom ≫ U ◁ f✝
w : { f := f✝, comm := comm✝ }.f = g.f
⊢ { f := f✝, comm := comm✝ } = g
state_after: case mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
f✝¹ : X.fst ⟶ Y.fst
comm✝¹ : ∀ (U : C), f✝¹ ▷ U ≫ (Y.snd.β U).hom = (X.snd.β U).hom ≫ U ◁ f✝¹
f✝ : X.fst ⟶ Y.fst
comm✝ : ∀ (U : C), f✝ ▷ U ≫ (Y.snd.β U).hom = (X.snd.β U).hom ≫ U ◁ f✝
w : { f := f✝¹, comm := comm✝¹ }.f = { f := f✝, comm := comm✝ }.f
⊢ { f := f✝¹, comm := comm✝¹ } = { f := f✝, comm := comm✝ }

tactic: congr
state_before: case mk.mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X Y : Center C
f✝¹ : X.fst ⟶ Y.fst
comm✝¹ : ∀ (U : C), f✝¹ ▷ U ≫ (Y.snd.β U).hom = (X.snd.β U).hom ≫ U ◁ f✝¹
f✝ : X.fst ⟶ Y.fst
comm✝ : ∀ (U : C), f✝ ▷ U ≫ (Y.snd.β U).hom = (X.snd.β U).hom ≫ U ◁ f✝
w : { f := f✝¹, comm := comm✝¹ }.f = { f := f✝, comm := comm✝ }.f
⊢ { f := f✝¹, comm := comm✝¹ } = { f := f✝, comm := comm✝ }
state_after: no goals
Theorem: Basis.linearIndependent
File: Mathlib/LinearAlgebra/Basis.lean

tactic: rw [hl, LinearEquiv.map_zero]
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
l : ι →₀ R
hl : (Finsupp.total ι M R ⇑b) l = 0
⊢ b.repr ((Finsupp.total ι M R ⇑b) l) = 0
state_after: no goals
Theorem: CategoryTheory.Iso.self_symm_id_assoc
File: Mathlib/CategoryTheory/Iso.lean

tactic: rw [← trans_assoc, self_symm_id, refl_trans]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
α : X ≅ Y
β : X ≅ Z
⊢ α ≪≫ α.symm ≪≫ β = β
state_after: no goals
Theorem: ENat.iInf_coe_ne_top
File: Mathlib/Data/ENat/Lattice.lean

tactic: rw [Ne, iInf_coe_eq_top, not_isEmpty_iff]
state_before: ι : Sort u_1
f : ι → ℕ
s : Set ℕ
⊢ ⨅ i, ↑(f i) ≠ ⊤ ↔ Nonempty ι
state_after: no goals
Theorem: LieModule.coe_chainTop
File: Mathlib/Algebra/Lie/Weights/Chain.lean

tactic: rw [← nsmul_eq_smul_cast ℤ]
state_before: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
⊢ ⇑(chainTop α β) = ↑(chainTopCoeff α β) • α + ⇑β
state_after: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
⊢ ⇑(chainTop α β) = chainTopCoeff α β • α + ⇑β

tactic: rfl
state_before: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
⊢ ⇑(chainTop α β) = chainTopCoeff α β • α + ⇑β
state_after: no goals
Theorem: Nat.factorization_eq_zero_iff_remainder
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: refine ⟨factorization_eq_zero_of_remainder i, fun h => ?_⟩
state_before: a b m n p✝ p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
⊢ ¬p ∣ r ↔ (p * i + r).factorization p = 0
state_after: a b m n p✝ p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : (p * i + r).factorization p = 0
⊢ ¬p ∣ r

tactic: rw [factorization_eq_zero_iff] at h
state_before: a b m n p✝ p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : (p * i + r).factorization p = 0
⊢ ¬p ∣ r
state_after: a b m n p✝ p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : ¬Prime p ∨ ¬p ∣ p * i + r ∨ p * i + r = 0
⊢ ¬p ∣ r

tactic: contrapose! h
state_before: a b m n p✝ p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : ¬Prime p ∨ ¬p ∣ p * i + r ∨ p * i + r = 0
⊢ ¬p ∣ r
state_after: a b m n p✝ p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : p ∣ r
⊢ Prime p ∧ p ∣ p * i + r ∧ p * i + r ≠ 0

tactic: refine ⟨pp, ?_, ?_⟩
state_before: a b m n p✝ p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : p ∣ r
⊢ Prime p ∧ p ∣ p * i + r ∧ p * i + r ≠ 0
state_after: case refine_1
a b m n p✝ p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : p ∣ r
⊢ p ∣ p * i + r

case refine_2
a b m n p✝ p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : p ∣ r
⊢ p * i + r ≠ 0

tactic: rwa [← Nat.dvd_add_iff_right (dvd_mul_right p i)]
state_before: case refine_1
a b m n p✝ p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : p ∣ r
⊢ p ∣ p * i + r
state_after: no goals

tactic: contrapose! hr0
state_before: case refine_2
a b m n p✝ p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : p ∣ r
⊢ p * i + r ≠ 0
state_after: case refine_2
a b m n p✝ p r i : ℕ
pp : Prime p
h : p ∣ r
hr0 : p * i + r = 0
⊢ r = 0

tactic: exact (add_eq_zero_iff.mp hr0).2
state_before: case refine_2
a b m n p✝ p r i : ℕ
pp : Prime p
h : p ∣ r
hr0 : p * i + r = 0
⊢ r = 0
state_after: no goals
Theorem: MeasureTheory.Measure.MutuallySingular.restrict_compl_nullSet
File: Mathlib/MeasureTheory/Measure/MutuallySingular.lean

tactic: simp
state_before: α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
h : μ ⟂ₘ ν
⊢ ν.restrict h.nullSetᶜ = 0
state_after: no goals
Theorem: ProbabilityTheory.condCount_compl
File: Mathlib/Probability/CondCount.lean

tactic: rw [← condCount_union hs disjoint_compl_right, Set.union_compl_self,
  (condCount_isProbabilityMeasure hs hs').measure_univ]
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t✝ u t : Set Ω
hs : s.Finite
hs' : s.Nonempty
⊢ (condCount s) t + (condCount s) tᶜ = 1
state_after: no goals
Theorem: ModuleCat.toKernelSubobject_arrow
File: Mathlib/Algebra/Category/ModuleCat/Subobject.lean

tactic: suffices ((arrow ((kernelSubobject f))) ∘ (kernelSubobjectIso f ≪≫ kernelIsoKer f).inv) x = x by
  convert this
state_before: R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
⊢ (kernelSubobject f).arrow (toKernelSubobject x) = ↑x
state_after: R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
⊢ (⇑(kernelSubobject f).arrow ∘ ⇑(kernelSubobjectIso f ≪≫ kernelIsoKer f).inv) x = ↑x

tactic: rw [Iso.trans_inv, ← coe_comp, Category.assoc]
state_before: R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
⊢ (⇑(kernelSubobject f).arrow ∘ ⇑(kernelSubobjectIso f ≪≫ kernelIsoKer f).inv) x = ↑x
state_after: R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
⊢ ((kernelIsoKer f).inv ≫ (kernelSubobjectIso f).inv ≫ (kernelSubobject f).arrow) x = ↑x

tactic: simp only [Category.assoc, kernelSubobject_arrow', kernelIsoKer_inv_kernel_ι]
state_before: R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
⊢ ((kernelIsoKer f).inv ≫ (kernelSubobjectIso f).inv ≫ (kernelSubobject f).arrow) x = ↑x
state_after: R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
⊢ (LinearMap.ker f).subtype x = ↑x

tactic: aesop_cat
state_before: R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
⊢ (LinearMap.ker f).subtype x = ↑x
state_after: no goals

tactic: convert this
state_before: R : Type u
inst✝ : Ring R
M✝ : ModuleCat R
M N : ModuleCat R
f : M ⟶ N
x : ↥(LinearMap.ker f)
this : (⇑(kernelSubobject f).arrow ∘ ⇑(kernelSubobjectIso f ≪≫ kernelIsoKer f).inv) x = ↑x
⊢ (kernelSubobject f).arrow (toKernelSubobject x) = ↑x
state_after: no goals
Theorem: MaximalSpectrum.toPrimeSpectrum_range
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Maximal.lean

tactic: simp only [isClosed_singleton_iff_isMaximal]
state_before: R : Type u
inst✝ : CommRing R
⊢ range toPrimeSpectrum = {x | IsClosed {x}}
state_after: R : Type u
inst✝ : CommRing R
⊢ range toPrimeSpectrum = {x | x.asIdeal.IsMaximal}

tactic: ext ⟨x, _⟩
state_before: R : Type u
inst✝ : CommRing R
⊢ range toPrimeSpectrum = {x | x.asIdeal.IsMaximal}
state_after: case h.mk
R : Type u
inst✝ : CommRing R
x : Ideal R
isPrime✝ : x.IsPrime
⊢ { asIdeal := x, isPrime := isPrime✝ } ∈ range toPrimeSpectrum ↔
    { asIdeal := x, isPrime := isPrime✝ } ∈ {x | x.asIdeal.IsMaximal}

tactic: exact ⟨fun ⟨y, hy⟩ => hy ▸ y.IsMaximal, fun hx => ⟨⟨x, hx⟩, rfl⟩⟩
state_before: case h.mk
R : Type u
inst✝ : CommRing R
x : Ideal R
isPrime✝ : x.IsPrime
⊢ { asIdeal := x, isPrime := isPrime✝ } ∈ range toPrimeSpectrum ↔
    { asIdeal := x, isPrime := isPrime✝ } ∈ {x | x.asIdeal.IsMaximal}
state_after: no goals
Theorem: torusIntegral_neg
File: Mathlib/MeasureTheory/Integral/TorusIntegral.lean

tactic: simp [torusIntegral, integral_neg]
state_before: n : ℕ
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ g : (Fin n → ℂ) → E
c✝ : Fin n → ℂ
R✝ : Fin n → ℝ
f : (Fin n → ℂ) → E
c : Fin n → ℂ
R : Fin n → ℝ
⊢ (∯ (x : Fin n → ℂ) in T(c, R), -f x) = -∯ (x : Fin n → ℂ) in T(c, R), f x
state_after: no goals
Theorem: AffineIsometryEquiv.dist_pointReflection_fixed
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: rw [← (pointReflection 𝕜 x).dist_map y x, pointReflection_self]
state_before: 𝕜 : Type u_1
V : Type u_2
V₁ : Type u_3
V₁' : Type u_4
V₂ : Type u_5
V₃ : Type u_6
V₄ : Type u_7
P₁ : Type u_8
P₁' : Type u_9
P : Type u_10
P₂ : Type u_11
P₃ : Type u_12
P₄ : Type u_13
inst✝²⁵ : NormedField 𝕜
inst✝²⁴ : SeminormedAddCommGroup V
inst✝²³ : NormedSpace 𝕜 V
inst✝²² : PseudoMetricSpace P
inst✝²¹ : NormedAddTorsor V P
inst✝²⁰ : SeminormedAddCommGroup V₁
inst✝¹⁹ : NormedSpace 𝕜 V₁
inst✝¹⁸ : PseudoMetricSpace P₁
inst✝¹⁷ : NormedAddTorsor V₁ P₁
inst✝¹⁶ : SeminormedAddCommGroup V₁'
inst✝¹⁵ : NormedSpace 𝕜 V₁'
inst✝¹⁴ : MetricSpace P₁'
inst✝¹³ : NormedAddTorsor V₁' P₁'
inst✝¹² : SeminormedAddCommGroup V₂
inst✝¹¹ : NormedSpace 𝕜 V₂
inst✝¹⁰ : PseudoMetricSpace P₂
inst✝⁹ : NormedAddTorsor V₂ P₂
inst✝⁸ : SeminormedAddCommGroup V₃
inst✝⁷ : NormedSpace 𝕜 V₃
inst✝⁶ : PseudoMetricSpace P₃
inst✝⁵ : NormedAddTorsor V₃ P₃
inst✝⁴ : SeminormedAddCommGroup V₄
inst✝³ : NormedSpace 𝕜 V₄
inst✝² : PseudoMetricSpace P₄
inst✝¹ : NormedAddTorsor V₄ P₄
e : P ≃ᵃⁱ[𝕜] P₂
α : Type u_14
inst✝ : TopologicalSpace α
x y : P
⊢ dist ((pointReflection 𝕜 x) y) x = dist y x
state_after: no goals
Theorem: Ordinal.nmul_le_nmul_of_nonneg_right
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [nmul_comm, nmul_comm b]
state_before: a b c d : Ordinal.{u}
h₁ : a ≤ b
h₂ : 0 ≤ c
⊢ a ⨳ c ≤ b ⨳ c
state_after: a b c d : Ordinal.{u}
h₁ : a ≤ b
h₂ : 0 ≤ c
⊢ c ⨳ a ≤ c ⨳ b

tactic: exact nmul_le_nmul_of_nonneg_left h₁ h₂
state_before: a b c d : Ordinal.{u}
h₁ : a ≤ b
h₂ : 0 ≤ c
⊢ c ⨳ a ≤ c ⨳ b
state_after: no goals
Theorem: Finset.prod_equiv
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: refine prod_nbij' e e.symm ?_ ?_ ?_ ?_ hfg <;> simp [hst]
state_before: ι✝ : Type u_1
κ✝ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α✝
a : α✝
f✝ g✝ : α✝ → β
inst✝¹ : CommMonoid β
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝ : CommMonoid α
s : Finset ι
t : Finset κ
f : ι → α
g : κ → α
e : ι ≃ κ
hst : ∀ (i : ι), i ∈ s ↔ e i ∈ t
hfg : ∀ i ∈ s, f i = g (e i)
⊢ ∏ i ∈ s, f i = ∏ i ∈ t, g i
state_after: no goals
Theorem: SeminormedAddCommGroup.cauchySeq_of_le_geometric
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: simpa [dist_eq_norm] using h
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : SeminormedAddCommGroup α
r✝ C✝ : ℝ
f : ℕ → α
C r : ℝ
hr : r < 1
u : ℕ → α
h : ∀ (n : ℕ), ‖u n - u (n + 1)‖ ≤ C * r ^ n
⊢ ∀ (n : ℕ), dist (u n) (u (n + 1)) ≤ C * r ^ n
state_after: no goals
Theorem: FirstOrder.Language.empty_card
File: Mathlib/ModelTheory/Basic.lean

tactic: simp [card_eq_card_functions_add_card_relations]
state_before: L : Language
L' : Language
⊢ Language.empty.card = 0
state_after: no goals
Theorem: Commute.orderOf_dvd_lcm_mul
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: by_cases h0 : orderOf x = 0
state_before: 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 : ℕ
h : Commute x y
⊢ orderOf y ∣ (orderOf x).lcm (orderOf (x * y))
state_after: case pos
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 : ℕ
h : Commute x y
h0 : orderOf x = 0
⊢ orderOf y ∣ (orderOf x).lcm (orderOf (x * y))

case neg
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 : ℕ
h : Commute x y
h0 : ¬orderOf x = 0
⊢ orderOf y ∣ (orderOf x).lcm (orderOf (x * y))

tactic: conv_lhs =>
  rw [← one_mul y, ← pow_orderOf_eq_one x, ← succ_pred_eq_of_pos (Nat.pos_of_ne_zero h0),
    _root_.pow_succ, mul_assoc]
state_before: case neg
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 : ℕ
h : Commute x y
h0 : ¬orderOf x = 0
⊢ orderOf y ∣ (orderOf x).lcm (orderOf (x * y))
state_after: case neg
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 : ℕ
h : Commute x y
h0 : ¬orderOf x = 0
⊢ orderOf (x ^ (orderOf x).pred * (x * y)) ∣ (orderOf x).lcm (orderOf (x * y))

tactic: exact
  (((Commute.refl x).mul_right h).pow_left _).orderOf_mul_dvd_lcm.trans
    (lcm_dvd_iff.2 ⟨(orderOf_pow_dvd _).trans (dvd_lcm_left _ _), dvd_lcm_right _ _⟩)
state_before: case neg
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 : ℕ
h : Commute x y
h0 : ¬orderOf x = 0
⊢ orderOf (x ^ (orderOf x).pred * (x * y)) ∣ (orderOf x).lcm (orderOf (x * y))
state_after: no goals

tactic: rw [h0, lcm_zero_left]
state_before: case pos
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 : ℕ
h : Commute x y
h0 : orderOf x = 0
⊢ orderOf y ∣ (orderOf x).lcm (orderOf (x * y))
state_after: case pos
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 : ℕ
h : Commute x y
h0 : orderOf x = 0
⊢ orderOf y ∣ 0

tactic: apply dvd_zero
state_before: case pos
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 : ℕ
h : Commute x y
h0 : orderOf x = 0
⊢ orderOf y ∣ 0
state_after: no goals
Theorem: Finset.map_subtype_embedding_Iic
File: Mathlib/Order/Interval/Finset/Defs.lean

tactic: rw [subtype_Iic_eq]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderBot α
a : Subtype p
hp : ∀ ⦃a x : α⦄, x ≤ a → p a → p x
⊢ map (Embedding.subtype p) (Iic a) = Iic ↑a
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderBot α
a : Subtype p
hp : ∀ ⦃a x : α⦄, x ≤ a → p a → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Iic ↑a)) = Iic ↑a

tactic: exact Finset.subtype_map_of_mem fun x hx => hp (mem_Iic.1 hx) a.prop
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderBot α
a : Subtype p
hp : ∀ ⦃a x : α⦄, x ≤ a → p a → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Iic ↑a)) = Iic ↑a
state_after: no goals
Theorem: HomologicalComplex₂.total.mapAux.mapMap_D₁
File: Mathlib/Algebra/Homology/TotalComplex.lean

tactic: aesop_cat
state_before: C : Type u_1
inst✝⁵ : Category.{u_5, u_1} C
inst✝⁴ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝³ : DecidableEq I₁₂
inst✝² : TotalComplexShape c₁ c₂ c₁₂
inst✝¹ : K.HasTotal c₁₂
inst✝ : L.HasTotal c₁₂
i₁₂ i₁₂' : I₁₂
⊢ GradedObject.mapMap (toGradedObjectMap φ) (c₁.π c₂ c₁₂) i₁₂ ≫ L.D₁ c₁₂ i₁₂ i₁₂' =
    K.D₁ c₁₂ i₁₂ i₁₂' ≫ GradedObject.mapMap (toGradedObjectMap φ) (c₁.π c₂ c₁₂) i₁₂'
state_after: no goals
Theorem: AlgebraicGeometry.IsAffineOpen.self_le_basicOpen_union_iff
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

tactic: rw [← hU.basicOpen_union_eq_self_iff, @comm _ Eq]
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
s : Set ↑Γ(X, U)
⊢ U ≤ ⨆ f, X.basicOpen ↑f ↔ Ideal.span s = ⊤
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
s : Set ↑Γ(X, U)
⊢ U ≤ ⨆ f, X.basicOpen ↑f ↔ U = ⨆ f, X.basicOpen ↑f

tactic: refine ⟨fun h => le_antisymm h ?_, le_of_eq⟩
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
s : Set ↑Γ(X, U)
⊢ U ≤ ⨆ f, X.basicOpen ↑f ↔ U = ⨆ f, X.basicOpen ↑f
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
s : Set ↑Γ(X, U)
h : U ≤ ⨆ f, X.basicOpen ↑f
⊢ ⨆ f, X.basicOpen ↑f ≤ U

tactic: simp only [iSup_le_iff, SetCoe.forall]
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
s : Set ↑Γ(X, U)
h : U ≤ ⨆ f, X.basicOpen ↑f
⊢ ⨆ f, X.basicOpen ↑f ≤ U
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
s : Set ↑Γ(X, U)
h : U ≤ ⨆ f, X.basicOpen ↑f
⊢ ∀ x ∈ s, X.basicOpen x ≤ U

tactic: intro x _
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
s : Set ↑Γ(X, U)
h : U ≤ ⨆ f, X.basicOpen ↑f
⊢ ∀ x ∈ s, X.basicOpen x ≤ U
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
s : Set ↑Γ(X, U)
h : U ≤ ⨆ f, X.basicOpen ↑f
x : ↑Γ(X, U)
h✝ : x ∈ s
⊢ X.basicOpen x ≤ U

tactic: exact X.basicOpen_le x
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
s : Set ↑Γ(X, U)
h : U ≤ ⨆ f, X.basicOpen ↑f
x : ↑Γ(X, U)
h✝ : x ∈ s
⊢ X.basicOpen x ≤ U
state_after: no goals
Theorem: Ideal.IsPrime.multiset_prod_le
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp [hp.ne_top]
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
s : Multiset (Ideal R)
P : Ideal R
hp : P.IsPrime
⊢ Multiset.prod 0 ≤ P ↔ ∃ I ∈ 0, I ≤ P
state_after: no goals

tactic: simp [hp.mul_le, ih]
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J K L : Ideal R
s✝ : Multiset (Ideal R)
P : Ideal R
hp : P.IsPrime
I : Ideal R
s : Multiset (Ideal R)
ih : s.prod ≤ P ↔ ∃ I ∈ s, I ≤ P
⊢ (I ::ₘ s).prod ≤ P ↔ ∃ I_1 ∈ I ::ₘ s, I_1 ≤ P
state_after: no goals
Theorem: Finite.Set.finite_biUnion
File: Mathlib/Data/Set/Finite.lean

tactic: rw [biUnion_eq_iUnion]
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
inst✝ : Finite ↑s
t : ι → Set α
H : ∀ i ∈ s, Finite ↑(t i)
⊢ Finite ↑(⋃ x ∈ s, t x)
state_after: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
inst✝ : Finite ↑s
t : ι → Set α
H : ∀ i ∈ s, Finite ↑(t i)
⊢ Finite ↑(⋃ x, t ↑x)

tactic: haveI : ∀ i : s, Finite (t i) := fun i => H i i.property
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
inst✝ : Finite ↑s
t : ι → Set α
H : ∀ i ∈ s, Finite ↑(t i)
⊢ Finite ↑(⋃ x, t ↑x)
state_after: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
inst✝ : Finite ↑s
t : ι → Set α
H : ∀ i ∈ s, Finite ↑(t i)
this : ∀ (i : ↑s), Finite ↑(t ↑i)
⊢ Finite ↑(⋃ x, t ↑x)

tactic: infer_instance
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
inst✝ : Finite ↑s
t : ι → Set α
H : ∀ i ∈ s, Finite ↑(t i)
this : ∀ (i : ↑s), Finite ↑(t ↑i)
⊢ Finite ↑(⋃ x, t ↑x)
state_after: no goals
Theorem: SeminormFamily.basisSets_singleton_mem
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: rw [Finset.sup_singleton]
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕝 : Type u_3
𝕝₂ : Type u_4
E : Type u_5
F : Type u_6
G : Type u_7
ι : Type u_8
ι' : Type u_9
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
i : ι
r : ℝ
hr : 0 < r
⊢ (p i).ball 0 r = ({i}.sup p).ball 0 r
state_after: no goals