1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Sylow.subtype_injective
File: Mathlib/GroupTheory/Sylow.lean

tactic: rw [SetLike.ext_iff] at h ⊢
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
P✝ : Sylow p G
K : Type u_2
inst✝ : Group K
ϕ : K →* G
N : Subgroup G
P Q : Sylow p G
hP : ↑P ≤ N
hQ : ↑Q ≤ N
h : P.subtype hP = Q.subtype hQ
⊢ P = Q
state_after: p : ℕ
G : Type u_1
inst✝¹ : Group G
P✝ : Sylow p G
K : Type u_2
inst✝ : Group K
ϕ : K →* G
N : Subgroup G
P Q : Sylow p G
hP : ↑P ≤ N
hQ : ↑Q ≤ N
h : ∀ (x : ↥N), x ∈ P.subtype hP ↔ x ∈ Q.subtype hQ
⊢ ∀ (x : G), x ∈ P ↔ x ∈ Q

tactic: exact fun g => ⟨fun hg => (h ⟨g, hP hg⟩).mp hg, fun hg => (h ⟨g, hQ hg⟩).mpr hg⟩
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
P✝ : Sylow p G
K : Type u_2
inst✝ : Group K
ϕ : K →* G
N : Subgroup G
P Q : Sylow p G
hP : ↑P ≤ N
hQ : ↑Q ≤ N
h : ∀ (x : ↥N), x ∈ P.subtype hP ↔ x ∈ Q.subtype hQ
⊢ ∀ (x : G), x ∈ P ↔ x ∈ Q
state_after: no goals
Theorem: Nat.nth_eq_orderEmbOfFin
File: Mathlib/Data/Nat/Nth.lean

tactic: rw [nth_eq_getD_sort hf, Finset.orderEmbOfFin_apply, List.getD_eq_get]
state_before: p : ℕ → Prop
hf : (setOf p).Finite
n : ℕ
hn : n < hf.toFinset.card
⊢ nth p n = (hf.toFinset.orderEmbOfFin ⋯) ⟨n, hn⟩
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.map_inverseImage_eq_of_isEquivalence
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

tactic: erw [P.inverseImage_equivalence_inverse_eq_map_functor hP F.asEquivalence, map_map,
  P.map_eq_of_iso F.asEquivalence.counitIso, map_id _ hP]
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
P : MorphismProperty D
hP : P.RespectsIso
F : C ⥤ D
inst✝ : F.IsEquivalence
⊢ (P.inverseImage F).map F = P
state_after: no goals
Theorem: IsHilbertSum.mk
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: rw [← LinearIsometry.coe_toLinearMap]
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁵ : RCLike 𝕜
E : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
inst✝ : ∀ (i : ι), CompleteSpace (G i)
hVortho : OrthogonalFamily 𝕜 G V
hVtotal : ⊤ ≤ (⨆ i, LinearMap.range (V i).toLinearMap).topologicalClosure
⊢ Function.Surjective ⇑hVortho.linearIsometry
state_after: ι : Type u_1
𝕜 : Type u_2
inst✝⁵ : RCLike 𝕜
E : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
inst✝ : ∀ (i : ι), CompleteSpace (G i)
hVortho : OrthogonalFamily 𝕜 G V
hVtotal : ⊤ ≤ (⨆ i, LinearMap.range (V i).toLinearMap).topologicalClosure
⊢ Function.Surjective ⇑hVortho.linearIsometry.toLinearMap

tactic: exact LinearMap.range_eq_top.mp
  (eq_top_iff.mpr <| hVtotal.trans_eq hVortho.range_linearIsometry.symm)
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁵ : RCLike 𝕜
E : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
inst✝ : ∀ (i : ι), CompleteSpace (G i)
hVortho : OrthogonalFamily 𝕜 G V
hVtotal : ⊤ ≤ (⨆ i, LinearMap.range (V i).toLinearMap).topologicalClosure
⊢ Function.Surjective ⇑hVortho.linearIsometry.toLinearMap
state_after: no goals
Theorem: PythagoreanTriple.classified
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: by_cases h0 : Int.gcd x y = 0
state_before: x y z : ℤ
h : PythagoreanTriple x y z
⊢ h.IsClassified
state_after: case pos
x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
⊢ h.IsClassified

case neg
x y z : ℤ
h : PythagoreanTriple x y z
h0 : ¬x.gcd y = 0
⊢ h.IsClassified

tactic: apply h.isClassified_of_normalize_isPrimitiveClassified
state_before: case neg
x y z : ℤ
h : PythagoreanTriple x y z
h0 : ¬x.gcd y = 0
⊢ h.IsClassified
state_after: case neg
x y z : ℤ
h : PythagoreanTriple x y z
h0 : ¬x.gcd y = 0
⊢ ⋯.IsPrimitiveClassified

tactic: apply h.normalize.isPrimitiveClassified_of_coprime
state_before: case neg
x y z : ℤ
h : PythagoreanTriple x y z
h0 : ¬x.gcd y = 0
⊢ ⋯.IsPrimitiveClassified
state_after: case neg
x y z : ℤ
h : PythagoreanTriple x y z
h0 : ¬x.gcd y = 0
⊢ (x / ↑(x.gcd y)).gcd (y / ↑(x.gcd y)) = 1

tactic: apply Int.gcd_div_gcd_div_gcd (Nat.pos_of_ne_zero h0)
state_before: case neg
x y z : ℤ
h : PythagoreanTriple x y z
h0 : ¬x.gcd y = 0
⊢ (x / ↑(x.gcd y)).gcd (y / ↑(x.gcd y)) = 1
state_after: no goals

tactic: have hx : x = 0 := by
  apply Int.natAbs_eq_zero.mp
  apply Nat.eq_zero_of_gcd_eq_zero_left h0
state_before: case pos
x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
⊢ h.IsClassified
state_after: case pos
x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
hx : x = 0
⊢ h.IsClassified

tactic: have hy : y = 0 := by
  apply Int.natAbs_eq_zero.mp
  apply Nat.eq_zero_of_gcd_eq_zero_right h0
state_before: case pos
x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
hx : x = 0
⊢ h.IsClassified
state_after: case pos
x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
hx : x = 0
hy : y = 0
⊢ h.IsClassified

tactic: use 0, 1, 0
state_before: case pos
x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
hx : x = 0
hy : y = 0
⊢ h.IsClassified
state_after: case h
x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
hx : x = 0
hy : y = 0
⊢ (x = 0 * (1 ^ 2 - 0 ^ 2) ∧ y = 0 * (2 * 1 * 0) ∨ x = 0 * (2 * 1 * 0) ∧ y = 0 * (1 ^ 2 - 0 ^ 2)) ∧ Int.gcd 1 0 = 1

tactic: field_simp [hx, hy]
state_before: case h
x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
hx : x = 0
hy : y = 0
⊢ (x = 0 * (1 ^ 2 - 0 ^ 2) ∧ y = 0 * (2 * 1 * 0) ∨ x = 0 * (2 * 1 * 0) ∧ y = 0 * (1 ^ 2 - 0 ^ 2)) ∧ Int.gcd 1 0 = 1
state_after: no goals

tactic: apply Int.natAbs_eq_zero.mp
state_before: x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
⊢ x = 0
state_after: x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
⊢ x.natAbs = 0

tactic: apply Nat.eq_zero_of_gcd_eq_zero_left h0
state_before: x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
⊢ x.natAbs = 0
state_after: no goals

tactic: apply Int.natAbs_eq_zero.mp
state_before: x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
hx : x = 0
⊢ y = 0
state_after: x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
hx : x = 0
⊢ y.natAbs = 0

tactic: apply Nat.eq_zero_of_gcd_eq_zero_right h0
state_before: x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
hx : x = 0
⊢ y.natAbs = 0
state_after: no goals
Theorem: Nat.mem_factoredNumbers'
File: Mathlib/NumberTheory/SmoothNumbers.lean

tactic: obtain ⟨p, hp₁, hp₂⟩ := exists_infinite_primes (1 + Finset.sup s id)
state_before: s : Finset ℕ
m : ℕ
⊢ m ∈ factoredNumbers s ↔ ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s
state_after: case intro.intro
s : Finset ℕ
m p : ℕ
hp₁ : 1 + s.sup id ≤ p
hp₂ : Prime p
⊢ m ∈ factoredNumbers s ↔ ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s

tactic: rw [mem_factoredNumbers_iff_forall_le]
state_before: case intro.intro
s : Finset ℕ
m p : ℕ
hp₁ : 1 + s.sup id ≤ p
hp₂ : Prime p
⊢ m ∈ factoredNumbers s ↔ ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s
state_after: case intro.intro
s : Finset ℕ
m p : ℕ
hp₁ : 1 + s.sup id ≤ p
hp₂ : Prime p
⊢ (m ≠ 0 ∧ ∀ p ≤ m, Prime p → p ∣ m → p ∈ s) ↔ ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s

tactic: refine ⟨fun ⟨H₀, H₁⟩ ↦ fun p hp₁ hp₂ ↦ H₁ p (le_of_dvd (Nat.pos_of_ne_zero H₀) hp₂) hp₁ hp₂,
       fun H ↦ ⟨fun h ↦ lt_irrefl p ?_, fun p _ ↦ H p⟩⟩
state_before: case intro.intro
s : Finset ℕ
m p : ℕ
hp₁ : 1 + s.sup id ≤ p
hp₂ : Prime p
⊢ (m ≠ 0 ∧ ∀ p ≤ m, Prime p → p ∣ m → p ∈ s) ↔ ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s
state_after: case intro.intro
s : Finset ℕ
m p : ℕ
hp₁ : 1 + s.sup id ≤ p
hp₂ : Prime p
H : ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s
h : m = 0
⊢ p < p

tactic: calc
  p ≤ s.sup id := Finset.le_sup (f := @id ℕ) <| H p hp₂ <| h.symm ▸ dvd_zero p
  _ < 1 + s.sup id := lt_one_add _
  _ ≤ p := hp₁
state_before: case intro.intro
s : Finset ℕ
m p : ℕ
hp₁ : 1 + s.sup id ≤ p
hp₂ : Prime p
H : ∀ (p : ℕ), Prime p → p ∣ m → p ∈ s
h : m = 0
⊢ p < p
state_after: no goals
Theorem: continuousLinearMapToWeakSpace_eq_toWeakSpace
File: Mathlib/Topology/Algebra/Module/WeakDual.lean

tactic: rfl
state_before: α : Type u_1
𝕜 : Type u_2
𝕝 : Type u_3
R : Type u_4
E : Type u_5
F : Type u_6
M : Type u_7
inst✝⁶ : CommSemiring 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : TopologicalSpace E
x : E
⊢ (continuousLinearMapToWeakSpace 𝕜 E) x = (toWeakSpace 𝕜 E) x
state_after: no goals
Theorem: CategoryTheory.Functor.uncurry_obj_curry_obj_flip_flip'
File: Mathlib/CategoryTheory/Functor/Currying.lean

tactic: simp
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F₁ : B ⥤ C
F₂ : D ⥤ E
G : C × E ⥤ H
⊢ ∀ (X : B × D), (uncurry.obj (F₁ ⋙ (F₂ ⋙ (curry.obj G).flip).flip)).obj X = (F₁.prod F₂ ⋙ G).obj X
state_after: no goals

tactic: dsimp
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F₁ : B ⥤ C
F₂ : D ⥤ E
G : C × E ⥤ H
x✝² x✝¹ : B × D
x₁ : B
x₂ : D
y₁ : B
y₂ : D
x✝ : (x₁, x₂) ⟶ (y₁, y₂)
f₁ : (x₁, x₂).1 ⟶ (y₁, y₂).1
f₂ : (x₁, x₂).2 ⟶ (y₁, y₂).2
⊢ (uncurry.obj (F₁ ⋙ (F₂ ⋙ (curry.obj G).flip).flip)).map (f₁, f₂) =
    eqToHom ⋯ ≫ (F₁.prod F₂ ⋙ G).map (f₁, f₂) ≫ eqToHom ⋯
state_after: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F₁ : B ⥤ C
F₂ : D ⥤ E
G : C × E ⥤ H
x✝² x✝¹ : B × D
x₁ : B
x₂ : D
y₁ : B
y₂ : D
x✝ : (x₁, x₂) ⟶ (y₁, y₂)
f₁ : (x₁, x₂).1 ⟶ (y₁, y₂).1
f₂ : (x₁, x₂).2 ⟶ (y₁, y₂).2
⊢ G.map (F₁.map f₁, 𝟙 (F₂.obj x₂)) ≫ G.map (𝟙 (F₁.obj y₁), F₂.map f₂) =
    𝟙 (G.obj (F₁.obj x₁, F₂.obj x₂)) ≫ G.map (F₁.map f₁, F₂.map f₂) ≫ 𝟙 (G.obj (F₁.obj y₁, F₂.obj y₂))

tactic: simp only [Category.id_comp, Category.comp_id, ← G.map_comp, prod_comp]
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F₁ : B ⥤ C
F₂ : D ⥤ E
G : C × E ⥤ H
x✝² x✝¹ : B × D
x₁ : B
x₂ : D
y₁ : B
y₂ : D
x✝ : (x₁, x₂) ⟶ (y₁, y₂)
f₁ : (x₁, x₂).1 ⟶ (y₁, y₂).1
f₂ : (x₁, x₂).2 ⟶ (y₁, y₂).2
⊢ G.map (F₁.map f₁, 𝟙 (F₂.obj x₂)) ≫ G.map (𝟙 (F₁.obj y₁), F₂.map f₂) =
    𝟙 (G.obj (F₁.obj x₁, F₂.obj x₂)) ≫ G.map (F₁.map f₁, F₂.map f₂) ≫ 𝟙 (G.obj (F₁.obj y₁, F₂.obj y₂))
state_after: no goals
Theorem: MulAction.orbit.eq_or_disjoint
File: Mathlib/GroupTheory/GroupAction/Blocks.lean

tactic: apply (em (Disjoint (orbit G a) (orbit G b))).symm.imp _ id
state_before: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
a b : X
⊢ orbit G a = orbit G b ∨ Disjoint (orbit G a) (orbit G b)
state_after: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
a b : X
⊢ ¬Disjoint (orbit G a) (orbit G b) → orbit G a = orbit G b

tactic: simp (config := { contextual := true })
  only [Set.not_disjoint_iff, ← orbit_eq_iff, forall_exists_index, and_imp, eq_comm, implies_true]
state_before: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
a b : X
⊢ ¬Disjoint (orbit G a) (orbit G b) → orbit G a = orbit G b
state_after: no goals
Theorem: IsLocalization.isInteger_smul
File: Mathlib/RingTheory/Localization/Integer.lean

tactic: rcases hb with ⟨b', hb⟩
state_before: R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommSemiring P
a : R
b : S
hb : IsInteger R b
⊢ IsInteger R (a • b)
state_after: case intro
R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommSemiring P
a : R
b : S
b' : R
hb : (algebraMap R S) b' = b
⊢ IsInteger R (a • b)

tactic: use a * b'
state_before: case intro
R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommSemiring P
a : R
b : S
b' : R
hb : (algebraMap R S) b' = b
⊢ IsInteger R (a • b)
state_after: case h
R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommSemiring P
a : R
b : S
b' : R
hb : (algebraMap R S) b' = b
⊢ (algebraMap R S) (a * b') = a • b

tactic: rw [← hb, (algebraMap R S).map_mul, Algebra.smul_def]
state_before: case h
R : Type u_1
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommSemiring P
a : R
b : S
b' : R
hb : (algebraMap R S) b' = b
⊢ (algebraMap R S) (a * b') = a • b
state_after: no goals
Theorem: MvPolynomial.bind₂_comp_bind₂
File: Mathlib/Algebra/MvPolynomial/Monad.lean

tactic: ext : 2 <;> simp
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
g : S →+* MvPolynomial σ T
⊢ (bind₂ g).comp (bind₂ f) = bind₂ ((bind₂ g).comp f)
state_after: no goals
Theorem: CauchyFilter.comp_gen
File: Mathlib/Topology/UniformSpace/Completion.lean

tactic: rw [lift'_lift'_assoc]
state_before: α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ (((𝓤 α).lift' gen).lift' fun s => s ○ s) = (𝓤 α).lift' fun s => gen s ○ gen s
state_after: case hg
α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ Monotone gen

case hh
α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ Monotone fun s => s ○ s

tactic: exact monotone_gen
state_before: case hg
α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ Monotone gen
state_after: no goals

tactic: exact monotone_id.compRel monotone_id
state_before: case hh
α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ Monotone fun s => s ○ s
state_after: no goals

tactic: rw [lift'_lift'_assoc]
state_before: α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ ((𝓤 α).lift' fun s => gen (s ○ s)) = ((𝓤 α).lift' fun s => s ○ s).lift' gen
state_after: case hg
α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ Monotone fun s => s ○ s

case hh
α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ Monotone gen

tactic: exact monotone_id.compRel monotone_id
state_before: case hg
α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ Monotone fun s => s ○ s
state_after: no goals

tactic: exact monotone_gen
state_before: case hh
α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ Monotone gen
state_after: no goals
Theorem: Equiv.Perm.Disjoint.mul_left
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: cases H1 x <;> cases H2 x <;> simp [*]
state_before: α : Type u_1
f g h : Perm α
H1 : f.Disjoint h
H2 : g.Disjoint h
x : α
⊢ (f * g) x = x ∨ h x = x
state_after: no goals
Theorem: PowerSeries.coeff_order
File: Mathlib/RingTheory/PowerSeries/Order.lean

tactic: classical
simp only [order, order_finite_iff_ne_zero.mp h, not_false_iff, dif_neg, PartENat.get_natCast']
generalize_proofs h
exact Nat.find_spec h
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
h : φ.order.Dom
⊢ (coeff R (φ.order.get h)) φ ≠ 0
state_after: no goals

tactic: simp only [order, order_finite_iff_ne_zero.mp h, not_false_iff, dif_neg, PartENat.get_natCast']
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
h : φ.order.Dom
⊢ (coeff R (φ.order.get h)) φ ≠ 0
state_after: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
h : φ.order.Dom
⊢ (coeff R (Nat.find ⋯)) φ ≠ 0

tactic: generalize_proofs h
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
h : φ.order.Dom
⊢ (coeff R (Nat.find ⋯)) φ ≠ 0
state_after: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
h✝ : φ.order.Dom
h : ∃ n, (coeff R n) φ ≠ 0
⊢ (coeff R (Nat.find h)) φ ≠ 0

tactic: exact Nat.find_spec h
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
h✝ : φ.order.Dom
h : ∃ n, (coeff R n) φ ≠ 0
⊢ (coeff R (Nat.find h)) φ ≠ 0
state_after: no goals
Theorem: PowerSeries.order_monomial_of_ne_zero
File: Mathlib/RingTheory/PowerSeries/Order.lean

tactic: classical
rw [order_monomial, if_neg h]
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
n : ℕ
a : R
h : a ≠ 0
⊢ ((monomial R n) a).order = ↑n
state_after: no goals

tactic: rw [order_monomial, if_neg h]
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
n : ℕ
a : R
h : a ≠ 0
⊢ ((monomial R n) a).order = ↑n
state_after: no goals
Theorem: PowerBasis.equivOfRoot_map
File: Mathlib/RingTheory/PowerBasis.lean

tactic: ext x
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Ring S
inst✝⁹ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Algebra A B
K : Type u_6
inst✝⁴ : Field K
S' : Type u_7
inst✝³ : CommRing S'
inst✝² : Algebra R S'
inst✝¹ : Algebra A S
inst✝ : Algebra A S'
pb : PowerBasis A S
e : S ≃ₐ[A] S'
h₁ : (aeval pb.gen) (minpoly A (pb.map e).gen) = 0
h₂ : (aeval (pb.map e).gen) (minpoly A pb.gen) = 0
⊢ pb.equivOfRoot (pb.map e) h₁ h₂ = e
state_after: case h
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Ring S
inst✝⁹ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Algebra A B
K : Type u_6
inst✝⁴ : Field K
S' : Type u_7
inst✝³ : CommRing S'
inst✝² : Algebra R S'
inst✝¹ : Algebra A S
inst✝ : Algebra A S'
pb : PowerBasis A S
e : S ≃ₐ[A] S'
h₁ : (aeval pb.gen) (minpoly A (pb.map e).gen) = 0
h₂ : (aeval (pb.map e).gen) (minpoly A pb.gen) = 0
x : S
⊢ (pb.equivOfRoot (pb.map e) h₁ h₂) x = e x

tactic: obtain ⟨f, rfl⟩ := pb.exists_eq_aeval' x
state_before: case h
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Ring S
inst✝⁹ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Algebra A B
K : Type u_6
inst✝⁴ : Field K
S' : Type u_7
inst✝³ : CommRing S'
inst✝² : Algebra R S'
inst✝¹ : Algebra A S
inst✝ : Algebra A S'
pb : PowerBasis A S
e : S ≃ₐ[A] S'
h₁ : (aeval pb.gen) (minpoly A (pb.map e).gen) = 0
h₂ : (aeval (pb.map e).gen) (minpoly A pb.gen) = 0
x : S
⊢ (pb.equivOfRoot (pb.map e) h₁ h₂) x = e x
state_after: case h.intro
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Ring S
inst✝⁹ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Algebra A B
K : Type u_6
inst✝⁴ : Field K
S' : Type u_7
inst✝³ : CommRing S'
inst✝² : Algebra R S'
inst✝¹ : Algebra A S
inst✝ : Algebra A S'
pb : PowerBasis A S
e : S ≃ₐ[A] S'
h₁ : (aeval pb.gen) (minpoly A (pb.map e).gen) = 0
h₂ : (aeval (pb.map e).gen) (minpoly A pb.gen) = 0
f : A[X]
⊢ (pb.equivOfRoot (pb.map e) h₁ h₂) ((aeval pb.gen) f) = e ((aeval pb.gen) f)

tactic: simp [aeval_algEquiv]
state_before: case h.intro
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Ring S
inst✝⁹ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Algebra A B
K : Type u_6
inst✝⁴ : Field K
S' : Type u_7
inst✝³ : CommRing S'
inst✝² : Algebra R S'
inst✝¹ : Algebra A S
inst✝ : Algebra A S'
pb : PowerBasis A S
e : S ≃ₐ[A] S'
h₁ : (aeval pb.gen) (minpoly A (pb.map e).gen) = 0
h₂ : (aeval (pb.map e).gen) (minpoly A pb.gen) = 0
f : A[X]
⊢ (pb.equivOfRoot (pb.map e) h₁ h₂) ((aeval pb.gen) f) = e ((aeval pb.gen) f)
state_after: no goals
Theorem: Nat.factorial_le_pow
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [pow_succ']
state_before: m n✝ n : ℕ
⊢ (n + 1) * (n + 1) ^ n = (n + 1) ^ (n + 1)
state_after: no goals
Theorem: MvPolynomial.IsSymmetric.rename
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

tactic: apply rename_injective _ e.symm.injective
state_before: σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
hφ : φ.IsSymmetric
e : σ ≃ τ
x✝ : Perm τ
⊢ (rename ⇑x✝) ((rename ⇑e) φ) = (rename ⇑e) φ
state_after: case a
σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
hφ : φ.IsSymmetric
e : σ ≃ τ
x✝ : Perm τ
⊢ (rename ⇑e.symm) ((rename ⇑x✝) ((rename ⇑e) φ)) = (rename ⇑e.symm) ((rename ⇑e) φ)

tactic: simp_rw [rename_rename, ← Equiv.coe_trans, Equiv.self_trans_symm, Equiv.coe_refl, rename_id]
state_before: case a
σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
hφ : φ.IsSymmetric
e : σ ≃ τ
x✝ : Perm τ
⊢ (rename ⇑e.symm) ((rename ⇑x✝) ((rename ⇑e) φ)) = (rename ⇑e.symm) ((rename ⇑e) φ)
state_after: case a
σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
hφ : φ.IsSymmetric
e : σ ≃ τ
x✝ : Perm τ
⊢ (rename ⇑((e.trans x✝).trans e.symm)) φ = φ

tactic: rw [hφ]
state_before: case a
σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
hφ : φ.IsSymmetric
e : σ ≃ τ
x✝ : Perm τ
⊢ (rename ⇑((e.trans x✝).trans e.symm)) φ = φ
state_after: no goals
Theorem: TopCat.Sheaf.hom_ext
File: Mathlib/Topology/Sheaves/SheafCondition/Sites.lean

tactic: apply (restrictHomEquivHom F F' h).symm.injective
state_before: C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ι : Type u_1
B : ι → Opens ↑X
F : Presheaf C X
F' : Sheaf C X
h : Opens.IsBasis (Set.range B)
α β : F ⟶ F'.val
he : ∀ (i : ι), α.app { unop := B i } = β.app { unop := B i }
⊢ α = β
state_after: case a
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ι : Type u_1
B : ι → Opens ↑X
F : Presheaf C X
F' : Sheaf C X
h : Opens.IsBasis (Set.range B)
α β : F ⟶ F'.val
he : ∀ (i : ι), α.app { unop := B i } = β.app { unop := B i }
⊢ (restrictHomEquivHom F F' h).symm α = (restrictHomEquivHom F F' h).symm β

tactic: ext i
state_before: case a
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ι : Type u_1
B : ι → Opens ↑X
F : Presheaf C X
F' : Sheaf C X
h : Opens.IsBasis (Set.range B)
α β : F ⟶ F'.val
he : ∀ (i : ι), α.app { unop := B i } = β.app { unop := B i }
⊢ (restrictHomEquivHom F F' h).symm α = (restrictHomEquivHom F F' h).symm β
state_after: case a.w.h
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ι : Type u_1
B : ι → Opens ↑X
F : Presheaf C X
F' : Sheaf C X
h : Opens.IsBasis (Set.range B)
α β : F ⟶ F'.val
he : ∀ (i : ι), α.app { unop := B i } = β.app { unop := B i }
i : (InducedCategory (Opens ↑X) B)ᵒᵖ
⊢ ((restrictHomEquivHom F F' h).symm α).app i = ((restrictHomEquivHom F F' h).symm β).app i

tactic: exact he i.unop
state_before: case a.w.h
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ι : Type u_1
B : ι → Opens ↑X
F : Presheaf C X
F' : Sheaf C X
h : Opens.IsBasis (Set.range B)
α β : F ⟶ F'.val
he : ∀ (i : ι), α.app { unop := B i } = β.app { unop := B i }
i : (InducedCategory (Opens ↑X) B)ᵒᵖ
⊢ ((restrictHomEquivHom F F' h).symm α).app i = ((restrictHomEquivHom F F' h).symm β).app i
state_after: no goals
Theorem: Multiset.mem_powersetCard
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp [powersetCard_coe']
state_before: α : Type u_1
n : ℕ
s t : Multiset α
l : List α
⊢ s ∈ powersetCard n ⟦l⟧ ↔ s ≤ ⟦l⟧ ∧ card s = n
state_after: no goals