1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: exists_max_ideal_of_mem_nonunits
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: have : Ideal.span ({a} : Set α) ≠ ⊤ := by
  intro H
  rw [Ideal.span_singleton_eq_top] at H
  contradiction
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
⊢ ∃ I, I.IsMaximal ∧ a ∈ I
state_after: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
⊢ ∃ I, I.IsMaximal ∧ a ∈ I

tactic: rcases Ideal.exists_le_maximal _ this with ⟨I, Imax, H⟩
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
⊢ ∃ I, I.IsMaximal ∧ a ∈ I
state_after: case intro.intro
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
I : Ideal α
Imax : I.IsMaximal
H : Ideal.span {a} ≤ I
⊢ ∃ I, I.IsMaximal ∧ a ∈ I

tactic: use I, Imax
state_before: case intro.intro
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
I : Ideal α
Imax : I.IsMaximal
H : Ideal.span {a} ≤ I
⊢ ∃ I, I.IsMaximal ∧ a ∈ I
state_after: case right
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
I : Ideal α
Imax : I.IsMaximal
H : Ideal.span {a} ≤ I
⊢ a ∈ I

tactic: apply H
state_before: case right
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
I : Ideal α
Imax : I.IsMaximal
H : Ideal.span {a} ≤ I
⊢ a ∈ I
state_after: case right.a
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
I : Ideal α
Imax : I.IsMaximal
H : Ideal.span {a} ≤ I
⊢ a ∈ Ideal.span {a}

tactic: apply Ideal.subset_span
state_before: case right.a
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
I : Ideal α
Imax : I.IsMaximal
H : Ideal.span {a} ≤ I
⊢ a ∈ Ideal.span {a}
state_after: case right.a.a
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
I : Ideal α
Imax : I.IsMaximal
H : Ideal.span {a} ≤ I
⊢ a ∈ {a}

tactic: exact Set.mem_singleton a
state_before: case right.a.a
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
this : Ideal.span {a} ≠ ⊤
I : Ideal α
Imax : I.IsMaximal
H : Ideal.span {a} ≤ I
⊢ a ∈ {a}
state_after: no goals

tactic: intro H
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
⊢ Ideal.span {a} ≠ ⊤
state_after: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
H : Ideal.span {a} = ⊤
⊢ False

tactic: rw [Ideal.span_singleton_eq_top] at H
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
H : Ideal.span {a} = ⊤
⊢ False
state_after: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
H : IsUnit a
⊢ False

tactic: contradiction
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
h : a ∈ nonunits α
H : IsUnit a
⊢ False
state_after: no goals
Theorem: CategoryTheory.Sieve.overEquiv_iff
File: Mathlib/CategoryTheory/Sites/Over.lean

tactic: obtain ⟨S, rfl⟩ := (overEquiv Y).symm.surjective S
state_before: C : Type u
inst✝ : Category.{v, u} C
X : C
Y : Over X
S : Sieve Y
Z : C
f : Z ⟶ Y.left
⊢ ((overEquiv Y) S).arrows f ↔ S.arrows (Over.homMk f ⋯)
state_after: case intro
C : Type u
inst✝ : Category.{v, u} C
X : C
Y : Over X
Z : C
f : Z ⟶ Y.left
S : Sieve Y.left
⊢ ((overEquiv Y) ((overEquiv Y).symm S)).arrows f ↔ ((overEquiv Y).symm S).arrows (Over.homMk f ⋯)

tactic: simp
state_before: case intro
C : Type u
inst✝ : Category.{v, u} C
X : C
Y : Over X
Z : C
f : Z ⟶ Y.left
S : Sieve Y.left
⊢ ((overEquiv Y) ((overEquiv Y).symm S)).arrows f ↔ ((overEquiv Y).symm S).arrows (Over.homMk f ⋯)
state_after: no goals
Theorem: Matrix.IsDiag.isSymm
File: Mathlib/LinearAlgebra/Matrix/IsDiag.lean

tactic: ext i j
state_before: α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix n n α
h : A.IsDiag
⊢ A.IsSymm
state_after: case a
α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix n n α
h : A.IsDiag
i j : n
⊢ Aᵀ i j = A i j

tactic: by_cases g : i = j
state_before: case a
α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix n n α
h : A.IsDiag
i j : n
⊢ Aᵀ i j = A i j
state_after: case pos
α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix n n α
h : A.IsDiag
i j : n
g : i = j
⊢ Aᵀ i j = A i j

case neg
α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix n n α
h : A.IsDiag
i j : n
g : ¬i = j
⊢ Aᵀ i j = A i j

tactic: simp [h g, h (Ne.symm g)]
state_before: case neg
α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix n n α
h : A.IsDiag
i j : n
g : ¬i = j
⊢ Aᵀ i j = A i j
state_after: no goals

tactic: rw [g, transpose_apply]
state_before: case pos
α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix n n α
h : A.IsDiag
i j : n
g : i = j
⊢ Aᵀ i j = A i j
state_after: no goals
Theorem: AlgebraicGeometry.StructureSheaf.const_congr
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: substs hf hg
state_before: R : Type u
inst✝ : CommRing R
f₁ f₂ g₁ g₂ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu : ∀ x ∈ U, g₁ ∈ x.asIdeal.primeCompl
hf : f₁ = f₂
hg : g₁ = g₂
⊢ const R f₁ g₁ U hu = const R f₂ g₂ U ⋯
state_after: R : Type u
inst✝ : CommRing R
f₁ g₁ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu : ∀ x ∈ U, g₁ ∈ x.asIdeal.primeCompl
⊢ const R f₁ g₁ U hu = const R f₁ g₁ U ⋯

tactic: rfl
state_before: R : Type u
inst✝ : CommRing R
f₁ g₁ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu : ∀ x ∈ U, g₁ ∈ x.asIdeal.primeCompl
⊢ const R f₁ g₁ U hu = const R f₁ g₁ U ⋯
state_after: no goals
Theorem: IsExtreme.extremePoints_subset_extremePoints
File: Mathlib/Analysis/Convex/Extreme.lean

tactic: simpa only [← isExtreme_singleton] using hAB.trans
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
ι : Type u_4
π : ι → Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
A B C : Set E
x : E
hAB : IsExtreme 𝕜 A B
x✝ : E
⊢ x✝ ∈ extremePoints 𝕜 B → x✝ ∈ extremePoints 𝕜 A
state_after: no goals
Theorem: bihimp_bot
File: Mathlib/Order/SymmDiff.lean

tactic: simp [bihimp]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : HeytingAlgebra α
a : α
⊢ a ⇔ ⊥ = aᶜ
state_after: no goals
Theorem: norm_add_mul_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: repeat' rw [← sq (M := ℝ)]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + 2 * re ⟪x, y⟫_𝕜 + ‖y‖ * ‖y‖
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * re ⟪x, y⟫_𝕜 + ‖y‖ ^ 2

tactic: exact norm_add_sq _ _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * re ⟪x, y⟫_𝕜 + ‖y‖ ^ 2
state_after: no goals

tactic: rw [← sq (M := ℝ)]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * re ⟪x, y⟫_𝕜 + ‖y‖ * ‖y‖
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ‖x + y‖ ^ 2 = ‖x‖ ^ 2 + 2 * re ⟪x, y⟫_𝕜 + ‖y‖ ^ 2
Theorem: String.Iterator.ValidFor.mk'
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simpa [List.reverseAux_eq] using mk
state_before: l r : List Char
⊢ ValidFor l r { s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }
state_after: no goals
Theorem: descPochhammer_ne_zero_eval_zero
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: simp [descPochhammer_eval_zero, h]
state_before: R : Type u
inst✝ : Ring R
n : ℕ
h : n ≠ 0
⊢ eval 0 (descPochhammer R n) = 0
state_after: no goals
Theorem: Mathlib.Tactic.ComputeDegree.coeff_sub_of_eq
File: Mathlib/Tactic/ComputeDegree.lean

tactic: subst hf hg
state_before: R : Type u_1
inst✝ : Ring R
n : ℕ
a b : R
f g : R[X]
hf : f.coeff n = a
hg : g.coeff n = b
⊢ (f - g).coeff n = a - b
state_after: R : Type u_1
inst✝ : Ring R
n : ℕ
f g : R[X]
⊢ (f - g).coeff n = f.coeff n - g.coeff n

tactic: apply coeff_sub
state_before: R : Type u_1
inst✝ : Ring R
n : ℕ
f g : R[X]
⊢ (f - g).coeff n = f.coeff n - g.coeff n
state_after: no goals
Theorem: Finsupp.update_erase_eq_update
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rw [erase_eq_update_zero, update_idem]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α →₀ M
a : α
b : M
⊢ (erase a f).update a b = f.update a b
state_after: no goals
Theorem: lcm_eq_one_iff
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: rw [lcm_units_coe_left, normalize_coe_units]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a b : α
x✝ : a ∣ 1 ∧ b ∣ 1
c : α
hc : 1 = a * c
d : α
hd : 1 = b * d
⊢ lcm ↑(Units.mkOfMulEqOne a c ⋯) ↑(Units.mkOfMulEqOne b d ⋯) = 1
state_after: no goals
Theorem: MeasureTheory.TendstoInMeasure.exists_seq_tendsto_ae'
File: Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean

tactic: obtain ⟨ms, hms⟩ := hfg.exists_seq_tendstoInMeasure_atTop
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝² : MetricSpace E
f✝ : ℕ → α → E
g✝ : α → E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hfg : TendstoInMeasure μ f u g
⊢ ∃ ns, ∀ᵐ (x : α) ∂μ, Tendsto (fun i => f (ns i) x) atTop (𝓝 (g x))
state_after: case intro
α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝² : MetricSpace E
f✝ : ℕ → α → E
g✝ : α → E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hfg : TendstoInMeasure μ f u g
ms : ℕ → ι
hms : TendstoInMeasure μ (fun n => f (ms n)) atTop g
⊢ ∃ ns, ∀ᵐ (x : α) ∂μ, Tendsto (fun i => f (ns i) x) atTop (𝓝 (g x))

tactic: obtain ⟨ns, -, hns⟩ := hms.exists_seq_tendsto_ae
state_before: case intro
α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝² : MetricSpace E
f✝ : ℕ → α → E
g✝ : α → E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hfg : TendstoInMeasure μ f u g
ms : ℕ → ι
hms : TendstoInMeasure μ (fun n => f (ms n)) atTop g
⊢ ∃ ns, ∀ᵐ (x : α) ∂μ, Tendsto (fun i => f (ns i) x) atTop (𝓝 (g x))
state_after: case intro.intro.intro
α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝² : MetricSpace E
f✝ : ℕ → α → E
g✝ : α → E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hfg : TendstoInMeasure μ f u g
ms : ℕ → ι
hms : TendstoInMeasure μ (fun n => f (ms n)) atTop g
ns : ℕ → ℕ
hns : ∀ᵐ (x : α) ∂μ, Tendsto (fun i => f (ms (ns i)) x) atTop (𝓝 (g x))
⊢ ∃ ns, ∀ᵐ (x : α) ∂μ, Tendsto (fun i => f (ns i) x) atTop (𝓝 (g x))

tactic: exact ⟨ms ∘ ns, hns⟩
state_before: case intro.intro.intro
α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝² : MetricSpace E
f✝ : ℕ → α → E
g✝ : α → E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hfg : TendstoInMeasure μ f u g
ms : ℕ → ι
hms : TendstoInMeasure μ (fun n => f (ms n)) atTop g
ns : ℕ → ℕ
hns : ∀ᵐ (x : α) ∂μ, Tendsto (fun i => f (ms (ns i)) x) atTop (𝓝 (g x))
⊢ ∃ ns, ∀ᵐ (x : α) ∂μ, Tendsto (fun i => f (ns i) x) atTop (𝓝 (g x))
state_after: no goals
Theorem: Filter.Eventually.ratCast_atBot
File: Mathlib/Order/Filter/Archimedean.lean

tactic: rw [← Rat.comap_cast_atBot (R := R)]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : LinearOrderedField R
inst✝ : Archimedean R
p : R → Prop
h : ∀ᶠ (x : R) in atBot, p x
⊢ ∀ᶠ (n : ℚ) in atBot, p ↑n
state_after: α : Type u_1
R : Type u_2
inst✝¹ : LinearOrderedField R
inst✝ : Archimedean R
p : R → Prop
h : ∀ᶠ (x : R) in atBot, p x
⊢ ∀ᶠ (n : ℚ) in Filter.comap Rat.cast atBot, p ↑n

tactic: exact h.comap _
state_before: α : Type u_1
R : Type u_2
inst✝¹ : LinearOrderedField R
inst✝ : Archimedean R
p : R → Prop
h : ∀ᶠ (x : R) in atBot, p x
⊢ ∀ᶠ (n : ℚ) in Filter.comap Rat.cast atBot, p ↑n
state_after: no goals
Theorem: Polynomial.irreducible_iff_roots_eq_zero_of_degree_le_three
File: Mathlib/Algebra/Polynomial/SpecificDegree.lean

tactic: have hp0 : p ≠ 0 := by rintro rfl; rw [natDegree_zero] at hp2; cases hp2
state_before: K : Type u_1
inst✝ : Field K
p : K[X]
hp2 : 2 ≤ p.natDegree
hp3 : p.natDegree ≤ 3
⊢ Irreducible p ↔ p.roots = 0
state_after: K : Type u_1
inst✝ : Field K
p : K[X]
hp2 : 2 ≤ p.natDegree
hp3 : p.natDegree ≤ 3
hp0 : p ≠ 0
⊢ Irreducible p ↔ p.roots = 0

tactic: rw [← irreducible_mul_leadingCoeff_inv,
    (monic_mul_leadingCoeff_inv hp0).irreducible_iff_roots_eq_zero_of_degree_le_three,
    mul_comm, roots_C_mul]
state_before: K : Type u_1
inst✝ : Field K
p : K[X]
hp2 : 2 ≤ p.natDegree
hp3 : p.natDegree ≤ 3
hp0 : p ≠ 0
⊢ Irreducible p ↔ p.roots = 0
state_after: case ha
K : Type u_1
inst✝ : Field K
p : K[X]
hp2 : 2 ≤ p.natDegree
hp3 : p.natDegree ≤ 3
hp0 : p ≠ 0
⊢ p.leadingCoeff⁻¹ ≠ 0

case hp2
K : Type u_1
inst✝ : Field K
p : K[X]
hp2 : 2 ≤ p.natDegree
hp3 : p.natDegree ≤ 3
hp0 : p ≠ 0
⊢ 2 ≤ (p * C p.leadingCoeff⁻¹).natDegree

case hp3
K : Type u_1
inst✝ : Field K
p : K[X]
hp2 : 2 ≤ p.natDegree
hp3 : p.natDegree ≤ 3
hp0 : p ≠ 0
⊢ (p * C p.leadingCoeff⁻¹).natDegree ≤ 3

tactic: rintro rfl
state_before: K : Type u_1
inst✝ : Field K
p : K[X]
hp2 : 2 ≤ p.natDegree
hp3 : p.natDegree ≤ 3
⊢ p ≠ 0
state_after: K : Type u_1
inst✝ : Field K
hp2 : 2 ≤ natDegree 0
hp3 : natDegree 0 ≤ 3
⊢ False

tactic: rw [natDegree_zero] at hp2
state_before: K : Type u_1
inst✝ : Field K
hp2 : 2 ≤ natDegree 0
hp3 : natDegree 0 ≤ 3
⊢ False
state_after: K : Type u_1
inst✝ : Field K
hp2 : 2 ≤ 0
hp3 : natDegree 0 ≤ 3
⊢ False

tactic: cases hp2
state_before: K : Type u_1
inst✝ : Field K
hp2 : 2 ≤ 0
hp3 : natDegree 0 ≤ 3
⊢ False
state_after: no goals

tactic: exact inv_ne_zero (leadingCoeff_ne_zero.mpr hp0)
state_before: case ha
K : Type u_1
inst✝ : Field K
p : K[X]
hp2 : 2 ≤ p.natDegree
hp3 : p.natDegree ≤ 3
hp0 : p ≠ 0
⊢ p.leadingCoeff⁻¹ ≠ 0
state_after: no goals

tactic: rwa [natDegree_mul_leadingCoeff_inv _ hp0]
state_before: case hp2
K : Type u_1
inst✝ : Field K
p : K[X]
hp2 : 2 ≤ p.natDegree
hp3 : p.natDegree ≤ 3
hp0 : p ≠ 0
⊢ 2 ≤ (p * C p.leadingCoeff⁻¹).natDegree
state_after: no goals

tactic: rwa [natDegree_mul_leadingCoeff_inv _ hp0]
state_before: case hp3
K : Type u_1
inst✝ : Field K
p : K[X]
hp2 : 2 ≤ p.natDegree
hp3 : p.natDegree ≤ 3
hp0 : p ≠ 0
⊢ (p * C p.leadingCoeff⁻¹).natDegree ≤ 3
state_after: no goals
Theorem: Holor.slice_unitVec_mul
File: Mathlib/Data/Holor.lean

tactic: simp [slice, mul, HolorIndex.take, unitVec, HolorIndex.drop, h]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
i j : ℕ
hid : i < d
x : Holor α ds
t : HolorIndex ds
h : i = j
⊢ (unitVec d j ⊗ x).slice i hid t = (if i = j then x else 0) t
state_after: no goals

tactic: simp [slice, mul, HolorIndex.take, unitVec, HolorIndex.drop, h]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
i j : ℕ
hid : i < d
x : Holor α ds
t : HolorIndex ds
h : ¬i = j
⊢ (unitVec d j ⊗ x).slice i hid t = (if i = j then x else 0) t
state_after: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
i j : ℕ
hid : i < d
x : Holor α ds
t : HolorIndex ds
h : ¬i = j
⊢ 0 = 0 t

tactic: rfl
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Ring α
i j : ℕ
hid : i < d
x : Holor α ds
t : HolorIndex ds
h : ¬i = j
⊢ 0 = 0 t
state_after: no goals
Theorem: NNRat.num_pow
File: Mathlib/Data/NNRat/Defs.lean

tactic: simp [num, Int.natAbs_pow]
state_before: α : Type u_1
p q✝ q : ℚ≥0
n : ℕ
⊢ (q ^ n).num = q.num ^ n
state_after: no goals
Theorem: SeparationQuotient.map_prod_map_mk_nhds
File: Mathlib/Topology/Inseparable.lean

tactic: rw [nhds_prod_eq, ← prod_map_map_eq', map_mk_nhds, map_mk_nhds, nhds_prod_eq]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s : Set X
f g : X → Y
t : Set (SeparationQuotient X)
x : X
y : Y
⊢ Filter.map (Prod.map mk mk) (𝓝 (x, y)) = 𝓝 (mk x, mk y)
state_after: no goals
Theorem: cycles'Map_id
File: Mathlib/Algebra/Homology/Homology.lean

tactic: dsimp only [cycles'Map]
state_before: ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasKernels V
C₁ C₂ C₃ : HomologicalComplex V c
f : C₁ ⟶ C₂
i : ι
⊢ cycles'Map (𝟙 C₁) i = 𝟙 (Subobject.underlying.obj (C₁.cycles' i))
state_after: ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasKernels V
C₁ C₂ C₃ : HomologicalComplex V c
f : C₁ ⟶ C₂
i : ι
⊢ (C₁.cycles' i).factorThru ((C₁.cycles' i).arrow ≫ (𝟙 C₁).f i) ⋯ = 𝟙 (Subobject.underlying.obj (C₁.cycles' i))

tactic: simp
state_before: ι : Type u_1
V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasKernels V
C₁ C₂ C₃ : HomologicalComplex V c
f : C₁ ⟶ C₂
i : ι
⊢ (C₁.cycles' i).factorThru ((C₁.cycles' i).arrow ≫ (𝟙 C₁).f i) ⋯ = 𝟙 (Subobject.underlying.obj (C₁.cycles' i))
state_after: no goals
Theorem: MulAction.IsBlockSystem.of_normal
File: Mathlib/GroupTheory/GroupAction/Blocks.lean

tactic: constructor
state_before: G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
⊢ IsBlockSystem G (Set.range fun a => orbit (↥N) a)
state_after: case left
G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
⊢ Setoid.IsPartition (Set.range fun a => orbit (↥N) a)

case right
G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
⊢ ∀ b ∈ Set.range fun a => orbit (↥N) a, IsBlock G b

tactic: apply IsPartition.of_orbits
state_before: case left
G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
⊢ Setoid.IsPartition (Set.range fun a => orbit (↥N) a)
state_after: no goals

tactic: intro b
state_before: case right
G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
⊢ ∀ b ∈ Set.range fun a => orbit (↥N) a, IsBlock G b
state_after: case right
G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
b : Set X
⊢ (b ∈ Set.range fun a => orbit (↥N) a) → IsBlock G b

tactic: rintro ⟨a, rfl⟩
state_before: case right
G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
b : Set X
⊢ (b ∈ Set.range fun a => orbit (↥N) a) → IsBlock G b
state_after: case right.intro
G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
a : X
⊢ IsBlock G ((fun a => orbit (↥N) a) a)

tactic: exact orbit.isBlock_of_normal a
state_before: case right.intro
G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
a : X
⊢ IsBlock G ((fun a => orbit (↥N) a) a)
state_after: no goals
Theorem: Nat.descFactorial_lt_pow
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rintro ⟨⟩
state_before: n : ℕ
hn : 1 ≤ n
⊢ 2 ≤ 0 → n.descFactorial 0 < n ^ 0
state_after: no goals

tactic: intro
state_before: n : ℕ
hn : 1 ≤ n
⊢ 2 ≤ 1 → n.descFactorial 1 < n ^ 1
state_after: n : ℕ
hn : 1 ≤ n
a✝ : 2 ≤ 1
⊢ n.descFactorial 1 < n ^ 1

tactic: contradiction
state_before: n : ℕ
hn : 1 ≤ n
a✝ : 2 ≤ 1
⊢ n.descFactorial 1 < n ^ 1
state_after: no goals

tactic: rw [descFactorial_succ, pow_succ', Nat.mul_comm, Nat.mul_comm n]
state_before: n : ℕ
hn : 1 ≤ n
k : ℕ
x✝ : 2 ≤ k + 2
⊢ n.descFactorial (k + 2) < n ^ (k + 2)
state_after: n : ℕ
hn : 1 ≤ n
k : ℕ
x✝ : 2 ≤ k + 2
⊢ n.descFactorial (k + 1) * (n - (k + 1)) < n ^ (k + 1) * n

tactic: exact Nat.mul_lt_mul_of_le_of_lt (descFactorial_le_pow _ _) (Nat.sub_lt hn k.zero_lt_succ)
  (Nat.pow_pos (Nat.lt_of_succ_le hn))
state_before: n : ℕ
hn : 1 ≤ n
k : ℕ
x✝ : 2 ≤ k + 2
⊢ n.descFactorial (k + 1) * (n - (k + 1)) < n ^ (k + 1) * n
state_after: no goals
Theorem: CategoryTheory.ShortComplex.cyclesMap'_neg
File: Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean

tactic: have γ : LeftHomologyMapData φ h₁ h₂ := default
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
⊢ cyclesMap' (-φ) h₁ h₂ = -cyclesMap' φ h₁ h₂
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
γ : LeftHomologyMapData φ h₁ h₂
⊢ cyclesMap' (-φ) h₁ h₂ = -cyclesMap' φ h₁ h₂

tactic: simp only [γ.cyclesMap'_eq, γ.neg.cyclesMap'_eq, LeftHomologyMapData.neg_φK]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
γ : LeftHomologyMapData φ h₁ h₂
⊢ cyclesMap' (-φ) h₁ h₂ = -cyclesMap' φ h₁ h₂
state_after: no goals
Theorem: List.nthLe_tail
File: Mathlib/Data/List/Basic.lean

tactic: simp only [length_tail] at h
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
i : ℕ
h : i < l.tail.length
⊢ i + 1 < l.length
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
i : ℕ
h : i < l.length - 1
⊢ i + 1 < l.length

tactic: omega
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
i : ℕ
h : i < l.length - 1
⊢ i + 1 < l.length
state_after: no goals

tactic: cases l <;> [cases h; rfl]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
i : ℕ
h : i < l.tail.length
h' : optParam (i + 1 < l.length) ⋯
⊢ l.tail.nthLe i h = l.nthLe (i + 1) h'
state_after: no goals