1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Filter.tendsto_mul_iff_of_ne_zero
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: refine ⟨fun hfg => ?_, fun hf => hf.mul hg⟩
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝⁴ : GroupWithZero G₀
inst✝³ : TopologicalSpace G₀
inst✝² : HasContinuousInv₀ G₀
inst✝¹ : ContinuousMul G₀
f✝ g✝ : α → G₀
inst✝ : T1Space G₀
f g : α → G₀
l : Filter α
x y : G₀
hg : Tendsto g l (𝓝 y)
hy : y ≠ 0
⊢ Tendsto (fun n => f n * g n) l (𝓝 (x * y)) ↔ Tendsto f l (𝓝 x)
state_after: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝⁴ : GroupWithZero G₀
inst✝³ : TopologicalSpace G₀
inst✝² : HasContinuousInv₀ G₀
inst✝¹ : ContinuousMul G₀
f✝ g✝ : α → G₀
inst✝ : T1Space G₀
f g : α → G₀
l : Filter α
x y : G₀
hg : Tendsto g l (𝓝 y)
hy : y ≠ 0
hfg : Tendsto (fun n => f n * g n) l (𝓝 (x * y))
⊢ Tendsto f l (𝓝 x)

tactic: rw [← mul_div_cancel_right₀ x hy]
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝⁴ : GroupWithZero G₀
inst✝³ : TopologicalSpace G₀
inst✝² : HasContinuousInv₀ G₀
inst✝¹ : ContinuousMul G₀
f✝ g✝ : α → G₀
inst✝ : T1Space G₀
f g : α → G₀
l : Filter α
x y : G₀
hg : Tendsto g l (𝓝 y)
hy : y ≠ 0
hfg : Tendsto (fun n => f n * g n) l (𝓝 (x * y))
⊢ Tendsto f l (𝓝 x)
state_after: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝⁴ : GroupWithZero G₀
inst✝³ : TopologicalSpace G₀
inst✝² : HasContinuousInv₀ G₀
inst✝¹ : ContinuousMul G₀
f✝ g✝ : α → G₀
inst✝ : T1Space G₀
f g : α → G₀
l : Filter α
x y : G₀
hg : Tendsto g l (𝓝 y)
hy : y ≠ 0
hfg : Tendsto (fun n => f n * g n) l (𝓝 (x * y))
⊢ Tendsto f l (𝓝 (x * y / y))

tactic: refine Tendsto.congr' ?_ (hfg.div hg hy)
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝⁴ : GroupWithZero G₀
inst✝³ : TopologicalSpace G₀
inst✝² : HasContinuousInv₀ G₀
inst✝¹ : ContinuousMul G₀
f✝ g✝ : α → G₀
inst✝ : T1Space G₀
f g : α → G₀
l : Filter α
x y : G₀
hg : Tendsto g l (𝓝 y)
hy : y ≠ 0
hfg : Tendsto (fun n => f n * g n) l (𝓝 (x * y))
⊢ Tendsto f l (𝓝 (x * y / y))
state_after: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝⁴ : GroupWithZero G₀
inst✝³ : TopologicalSpace G₀
inst✝² : HasContinuousInv₀ G₀
inst✝¹ : ContinuousMul G₀
f✝ g✝ : α → G₀
inst✝ : T1Space G₀
f g : α → G₀
l : Filter α
x y : G₀
hg : Tendsto g l (𝓝 y)
hy : y ≠ 0
hfg : Tendsto (fun n => f n * g n) l (𝓝 (x * y))
⊢ (fun n => f n * g n) / g =ᶠ[l] f

tactic: exact (hg.eventually_ne hy).mono fun n hn => mul_div_cancel_right₀ _ hn
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝⁴ : GroupWithZero G₀
inst✝³ : TopologicalSpace G₀
inst✝² : HasContinuousInv₀ G₀
inst✝¹ : ContinuousMul G₀
f✝ g✝ : α → G₀
inst✝ : T1Space G₀
f g : α → G₀
l : Filter α
x y : G₀
hg : Tendsto g l (𝓝 y)
hy : y ≠ 0
hfg : Tendsto (fun n => f n * g n) l (𝓝 (x * y))
⊢ (fun n => f n * g n) / g =ᶠ[l] f
state_after: no goals
Theorem: Nat.zero_union_range_succ
File: Mathlib/Data/Nat/Set.lean

tactic: ext n
state_before: ⊢ {0} ∪ range succ = univ
state_after: case h
n : ℕ
⊢ n ∈ {0} ∪ range succ ↔ n ∈ univ

tactic: cases n <;> simp
state_before: case h
n : ℕ
⊢ n ∈ {0} ∪ range succ ↔ n ∈ univ
state_after: no goals
Theorem: Ideal.prime_span_singleton_iff
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rcases eq_or_ne a 0 with rfl | ha
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
a : A
⊢ Prime (span {a}) ↔ Prime a
state_after: case inl
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ Prime (span {0}) ↔ Prime 0

case inr
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
a : A
ha : a ≠ 0
⊢ Prime (span {a}) ↔ Prime a

tactic: rw [Set.singleton_zero, span_zero, ← Ideal.zero_eq_bot, ← not_iff_not]
state_before: case inl
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ Prime (span {0}) ↔ Prime 0
state_after: case inl
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ ¬Prime 0 ↔ ¬Prime 0

tactic: simp only [not_prime_zero, not_false_eq_true]
state_before: case inl
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ ¬Prime 0 ↔ ¬Prime 0
state_after: no goals

tactic: have ha' : span {a} ≠ ⊥ := by simpa only [ne_eq, span_singleton_eq_bot] using ha
state_before: case inr
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
a : A
ha : a ≠ 0
⊢ Prime (span {a}) ↔ Prime a
state_after: case inr
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
a : A
ha : a ≠ 0
ha' : span {a} ≠ ⊥
⊢ Prime (span {a}) ↔ Prime a

tactic: rw [Ideal.prime_iff_isPrime ha', Ideal.span_singleton_prime ha]
state_before: case inr
R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
a : A
ha : a ≠ 0
ha' : span {a} ≠ ⊥
⊢ Prime (span {a}) ↔ Prime a
state_after: no goals

tactic: simpa only [ne_eq, span_singleton_eq_bot] using ha
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
a : A
ha : a ≠ 0
⊢ span {a} ≠ ⊥
state_after: no goals
Theorem: BialgHom.coe_coalgHom_mk
File: Mathlib/RingTheory/Bialgebra/Hom.lean

tactic: rfl
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
D : Type u_5
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A
inst✝¹⁰ : Algebra R A
inst✝⁹ : Semiring B
inst✝⁸ : Algebra R B
inst✝⁷ : Semiring C
inst✝⁶ : Algebra R C
inst✝⁵ : Semiring D
inst✝⁴ : Algebra R D
inst✝³ : CoalgebraStruct R A
inst✝² : CoalgebraStruct R B
inst✝¹ : CoalgebraStruct R C
inst✝ : CoalgebraStruct R D
f : A →ₗc[R] B
h : f.toFun 1 = 1
h₁ : ∀ (x y : A), f.toFun (x * y) = f.toFun x * f.toFun y
⊢ ↑{ toCoalgHom := f, map_one' := h, map_mul' := h₁ } = f
state_after: no goals
Theorem: Real.two_mul_arctan_inv_2_sub_arctan_inv_7
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw [two_mul_arctan, ← arctan_one, sub_eq_iff_eq_add, arctan_add] <;> norm_num
state_before: ⊢ 2 * arctan 2⁻¹ - arctan 7⁻¹ = π / 4
state_after: no goals
Theorem: Algebra.adjoin_root_eq_top_of_isSplittingField
File: Mathlib/FieldTheory/KummerExtension.lean

tactic: apply Subalgebra.map_injective (f := (adjoinRootXPowSubCEquiv hζ H hα).symm)
  (adjoinRootXPowSubCEquiv hζ H hα).symm.injective
state_before: K : Type u
inst✝³ : Field K
n : ℕ
hζ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
L : Type u_1
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsSplittingField K L (X ^ n - C a)
α : L
hα : α ^ n = (algebraMap K L) a
⊢ adjoin K {α} = ⊤
state_after: case a
K : Type u
inst✝³ : Field K
n : ℕ
hζ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
L : Type u_1
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsSplittingField K L (X ^ n - C a)
α : L
hα : α ^ n = (algebraMap K L) a
⊢ Subalgebra.map (↑(adjoinRootXPowSubCEquiv hζ H hα).symm) (adjoin K {α}) =
    Subalgebra.map ↑(adjoinRootXPowSubCEquiv hζ H hα).symm ⊤

tactic: rw [Algebra.map_top, (Algebra.range_top_iff_surjective _).mpr
  (adjoinRootXPowSubCEquiv hζ H hα).symm.surjective, AlgHom.map_adjoin,
  Set.image_singleton, AlgHom.coe_coe, adjoinRootXPowSubCEquiv_symm_eq_root, adjoinRoot_eq_top]
state_before: case a
K : Type u
inst✝³ : Field K
n : ℕ
hζ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
L : Type u_1
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsSplittingField K L (X ^ n - C a)
α : L
hα : α ^ n = (algebraMap K L) a
⊢ Subalgebra.map (↑(adjoinRootXPowSubCEquiv hζ H hα).symm) (adjoin K {α}) =
    Subalgebra.map ↑(adjoinRootXPowSubCEquiv hζ H hα).symm ⊤
state_after: no goals
Theorem: SheafOfModules.freeHomEquiv_symm_comp
File: Mathlib/Algebra/Category/ModuleCat/Sheaf/Free.lean

tactic: ext
state_before: C : Type u'
inst✝³ : Category.{v', u'} C
J : GrothendieckTopology C
R : Sheaf J RingCat
inst✝² : HasWeakSheafify J AddCommGrp
inst✝¹ : J.WEqualsLocallyBijective AddCommGrp
inst✝ : J.HasSheafCompose (forget₂ RingCat AddCommGrp)
M N : SheafOfModules R
I : Type u
s : I → M.sections
p : M ⟶ N
⊢ N.freeHomEquiv (M.freeHomEquiv.symm s ≫ p) = N.freeHomEquiv (N.freeHomEquiv.symm fun i => sectionsMap p (s i))
state_after: case h.h
C : Type u'
inst✝³ : Category.{v', u'} C
J : GrothendieckTopology C
R : Sheaf J RingCat
inst✝² : HasWeakSheafify J AddCommGrp
inst✝¹ : J.WEqualsLocallyBijective AddCommGrp
inst✝ : J.HasSheafCompose (forget₂ RingCat AddCommGrp)
M N : SheafOfModules R
I : Type u
s : I → M.sections
p : M ⟶ N
x✝ : I
X✝ : Cᵒᵖ
⊢ ↑(N.freeHomEquiv (M.freeHomEquiv.symm s ≫ p) x✝) X✝ =
    ↑(N.freeHomEquiv (N.freeHomEquiv.symm fun i => sectionsMap p (s i)) x✝) X✝

tactic: simp [freeHomEquiv_comp_apply]
state_before: case h.h
C : Type u'
inst✝³ : Category.{v', u'} C
J : GrothendieckTopology C
R : Sheaf J RingCat
inst✝² : HasWeakSheafify J AddCommGrp
inst✝¹ : J.WEqualsLocallyBijective AddCommGrp
inst✝ : J.HasSheafCompose (forget₂ RingCat AddCommGrp)
M N : SheafOfModules R
I : Type u
s : I → M.sections
p : M ⟶ N
x✝ : I
X✝ : Cᵒᵖ
⊢ ↑(N.freeHomEquiv (M.freeHomEquiv.symm s ≫ p) x✝) X✝ =
    ↑(N.freeHomEquiv (N.freeHomEquiv.symm fun i => sectionsMap p (s i)) x✝) X✝
state_after: no goals
Theorem: Multiset.prod_eq_one_iff
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

tactic: simpa using List.prod_eq_one_iff
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CanonicallyOrderedCommMonoid α
m : Multiset α
a : α
l : List α
⊢ prod ⟦l⟧ = 1 ↔ ∀ x ∈ ⟦l⟧, x = 1
state_after: no goals
Theorem: exists_countable_dense_bot_top
File: Mathlib/Topology/Bases.lean

tactic: simpa using dense_univ.exists_countable_dense_subset_bot_top
state_before: α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : SeparableSpace α
inst✝ : PartialOrder α
⊢ ∃ s, s.Countable ∧ Dense s ∧ (∀ (x : α), IsBot x → x ∈ s) ∧ ∀ (x : α), IsTop x → x ∈ s
state_after: no goals
Theorem: AkraBazziRecurrence.isLittleO_deriv_one_sub_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

tactic: filter_upwards [eventually_gt_atTop 1] with x hx
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ (deriv fun x => 1 - ε x) =ᶠ[atTop] fun z => -deriv ε z
state_after: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
⊢ deriv (fun x => 1 - ε x) x = -deriv ε x

tactic: rw [deriv_sub] <;> aesop
state_before: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
⊢ deriv (fun x => 1 - ε x) x = -deriv ε x
state_after: no goals

tactic: rw [isLittleO_neg_left]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ (fun z => -deriv ε z) =o[atTop] fun x => x⁻¹
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ deriv ε =o[atTop] fun x => x⁻¹

tactic: exact isLittleO_deriv_smoothingFn
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ deriv ε =o[atTop] fun x => x⁻¹
state_after: no goals
Theorem: CommRingCat.pushoutCocone_inr
File: Mathlib/Algebra/Category/Ring/Constructions.lean

tactic: letI := f.toAlgebra
state_before: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
⊢ B ⟶ (pushoutCocone f g).pt
state_after: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
this : Algebra ↑R ↑A := RingHom.toAlgebra f
⊢ B ⟶ (pushoutCocone f g).pt

tactic: letI := g.toAlgebra
state_before: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
this : Algebra ↑R ↑A := RingHom.toAlgebra f
⊢ B ⟶ (pushoutCocone f g).pt
state_after: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
this✝ : Algebra ↑R ↑A := RingHom.toAlgebra f
this : Algebra ↑R ↑B := RingHom.toAlgebra g
⊢ B ⟶ (pushoutCocone f g).pt

tactic: exact Algebra.TensorProduct.includeRight.toRingHom
state_before: R A B : CommRingCat
f : R ⟶ A
g : R ⟶ B
this✝ : Algebra ↑R ↑A := RingHom.toAlgebra f
this : Algebra ↑R ↑B := RingHom.toAlgebra g
⊢ B ⟶ (pushoutCocone f g).pt
state_after: no goals
Theorem: CategoryTheory.Limits.biprod_isoCoprod_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: ext <;> simp [← Iso.eq_comp_inv]
state_before: J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
D : Type uD
inst✝² : Category.{uD', uD} D
inst✝¹ : HasZeroMorphisms D
P Q X Y : C
inst✝ : HasBinaryBiproduct X Y
⊢ (biprod.isoCoprod X Y).hom = biprod.desc coprod.inl coprod.inr
state_after: no goals
Theorem: Nat.ceil_le_floor_add_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [ceil_le, Nat.cast_add, Nat.cast_one]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
⊢ ⌈a⌉₊ ≤ ⌊a⌋₊ + 1
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
⊢ a ≤ ↑⌊a⌋₊ + 1

tactic: exact (lt_floor_add_one a).le
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
⊢ a ≤ ↑⌊a⌋₊ + 1
state_after: no goals
Theorem: FirstOrder.Language.DirectLimit.comp_unify
File: Mathlib/ModelTheory/DirectLimit.lean

tactic: ext a
state_before: L : Language
ι : Type v
inst✝² : Preorder ι
G : ι → Type w
inst✝¹ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝ : DirectedSystem G fun i j h => ⇑(f i j h)
α : Type u_1
x : α → Σˣ f
i j : ι
ij : i ≤ j
h : i ∈ upperBounds (range (Sigma.fst ∘ x))
⊢ ⇑(f i j ij) ∘ unify f x i h = unify f x j ⋯
state_after: case h
L : Language
ι : Type v
inst✝² : Preorder ι
G : ι → Type w
inst✝¹ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝ : DirectedSystem G fun i j h => ⇑(f i j h)
α : Type u_1
x : α → Σˣ f
i j : ι
ij : i ≤ j
h : i ∈ upperBounds (range (Sigma.fst ∘ x))
a : α
⊢ (⇑(f i j ij) ∘ unify f x i h) a = unify f x j ⋯ a

tactic: simp [unify, DirectedSystem.map_map]
state_before: case h
L : Language
ι : Type v
inst✝² : Preorder ι
G : ι → Type w
inst✝¹ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝ : DirectedSystem G fun i j h => ⇑(f i j h)
α : Type u_1
x : α → Σˣ f
i j : ι
ij : i ≤ j
h : i ∈ upperBounds (range (Sigma.fst ∘ x))
a : α
⊢ (⇑(f i j ij) ∘ unify f x i h) a = unify f x j ⋯ a
state_after: no goals
Theorem: Fin.succAbove_ne_zero_zero
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [Fin.succAbove_of_castSucc_lt]
state_before: n m : ℕ
p : Fin (n + 1)
i j : Fin n
inst✝ : NeZero n
a : Fin (n + 1)
ha : a ≠ 0
⊢ a.succAbove 0 = 0
state_after: n m : ℕ
p : Fin (n + 1)
i j : Fin n
inst✝ : NeZero n
a : Fin (n + 1)
ha : a ≠ 0
⊢ castSucc 0 = 0

case h
n m : ℕ
p : Fin (n + 1)
i j : Fin n
inst✝ : NeZero n
a : Fin (n + 1)
ha : a ≠ 0
⊢ castSucc 0 < a

tactic: exact castSucc_zero'
state_before: n m : ℕ
p : Fin (n + 1)
i j : Fin n
inst✝ : NeZero n
a : Fin (n + 1)
ha : a ≠ 0
⊢ castSucc 0 = 0
state_after: no goals

tactic: exact Fin.pos_iff_ne_zero.2 ha
state_before: case h
n m : ℕ
p : Fin (n + 1)
i j : Fin n
inst✝ : NeZero n
a : Fin (n + 1)
ha : a ≠ 0
⊢ castSucc 0 < a
state_after: no goals
Theorem: List.length_eraseP_add_one
File: Mathlib/Data/List/Basic.lean

tactic: let ⟨_, l₁, l₂, _, _, h₁, h₂⟩ := exists_of_eraseP al pa
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
a : α
al : a ∈ l
pa : p a = true
⊢ (eraseP p l).length + 1 = l.length
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
p : α → Bool
l : List α
a : α
al : a ∈ l
pa : p a = true
w✝ : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
h₁ : l = l₁ ++ w✝ :: l₂
h₂ : eraseP p l = l₁ ++ l₂
⊢ (eraseP p l).length + 1 = l.length

tactic: rw [h₂, h₁, length_append, length_append]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
p : α → Bool
l : List α
a : α
al : a ∈ l
pa : p a = true
w✝ : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
h₁ : l = l₁ ++ w✝ :: l₂
h₂ : eraseP p l = l₁ ++ l₂
⊢ (eraseP p l).length + 1 = l.length
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
p : α → Bool
l : List α
a : α
al : a ∈ l
pa : p a = true
w✝ : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
h₁ : l = l₁ ++ w✝ :: l₂
h₂ : eraseP p l = l₁ ++ l₂
⊢ l₁.length + l₂.length + 1 = l₁.length + (w✝ :: l₂).length

tactic: rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
p : α → Bool
l : List α
a : α
al : a ∈ l
pa : p a = true
w✝ : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
h₁ : l = l₁ ++ w✝ :: l₂
h₂ : eraseP p l = l₁ ++ l₂
⊢ l₁.length + l₂.length + 1 = l₁.length + (w✝ :: l₂).length
state_after: no goals
Theorem: SimpleGraph.isClique_map_iff
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: obtain (ht | ht) := t.subsingleton_or_nontrivial
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
f : α ↪ β
t : Set β
⊢ (SimpleGraph.map f G).IsClique t ↔ t.Subsingleton ∨ ∃ s, G.IsClique s ∧ ⇑f '' s = t
state_after: case inl
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
f : α ↪ β
t : Set β
ht : t.Subsingleton
⊢ (SimpleGraph.map f G).IsClique t ↔ t.Subsingleton ∨ ∃ s, G.IsClique s ∧ ⇑f '' s = t

case inr
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
f : α ↪ β
t : Set β
ht : t.Nontrivial
⊢ (SimpleGraph.map f G).IsClique t ↔ t.Subsingleton ∨ ∃ s, G.IsClique s ∧ ⇑f '' s = t

tactic: simp [isClique_map_iff_of_nontrivial ht, ht.not_subsingleton]
state_before: case inr
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
f : α ↪ β
t : Set β
ht : t.Nontrivial
⊢ (SimpleGraph.map f G).IsClique t ↔ t.Subsingleton ∨ ∃ s, G.IsClique s ∧ ⇑f '' s = t
state_after: no goals

tactic: simp [IsClique.of_subsingleton, ht]
state_before: case inl
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t✝ : Set α
a b : α
f : α ↪ β
t : Set β
ht : t.Subsingleton
⊢ (SimpleGraph.map f G).IsClique t ↔ t.Subsingleton ∨ ∃ s, G.IsClique s ∧ ⇑f '' s = t
state_after: no goals
Theorem: ProperCone.mem_dual
File: Mathlib/Analysis/Convex/Cone/Proper.lean

tactic: aesop
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace ℝ E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
G : Type u_3
inst✝¹ : NormedAddCommGroup G
inst✝ : InnerProductSpace ℝ G
K : ProperCone ℝ E
y : E
⊢ y ∈ K.dual ↔ ∀ ⦃x : E⦄, x ∈ K → 0 ≤ ⟪x, y⟫_ℝ
state_after: no goals
Theorem: Finsupp.card_support_le_one
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp only [card_le_one_iff_subset_singleton, support_subset_singleton]
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
a a' : α
b : M
inst✝ : Nonempty α
f : α →₀ M
⊢ f.support.card ≤ 1 ↔ ∃ a, f = single a (f a)
state_after: no goals
Theorem: Multiset.countP_eq_zero
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [List.countP_eq_zero]
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
_l : List α
⊢ countP p (Quot.mk Setoid.r _l) = 0 ↔ ∀ a ∈ Quot.mk Setoid.r _l, ¬p a
state_after: no goals
Theorem: LieSubmodule.map_incl_le
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: conv_rhs => rw [← N.map_incl_top]
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
N : LieSubmodule R L M
N' : LieSubmodule R L ↥↑N
⊢ map N.incl N' ≤ N
state_after: 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
N : LieSubmodule R L M
N' : LieSubmodule R L ↥↑N
⊢ map N.incl N' ≤ map N.incl ⊤

tactic: exact LieSubmodule.map_mono le_top
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
N : LieSubmodule R L M
N' : LieSubmodule R L ↥↑N
⊢ map N.incl N' ≤ map N.incl ⊤
state_after: no goals
Theorem: Subgroup.mem_closure_pair
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: rw [← Set.singleton_union, Subgroup.closure_union, mem_sup]
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
N : Type u_5
inst✝¹ : Group N
C : Type u_6
inst✝ : CommGroup C
s t : Subgroup C
x✝ x y z : C
⊢ z ∈ closure {x, y} ↔ ∃ m n, x ^ m * y ^ n = z
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
N : Type u_5
inst✝¹ : Group N
C : Type u_6
inst✝ : CommGroup C
s t : Subgroup C
x✝ x y z : C
⊢ (∃ y_1 ∈ closure {x}, ∃ z_1 ∈ closure {y}, y_1 * z_1 = z) ↔ ∃ m n, x ^ m * y ^ n = z

tactic: simp_rw [mem_closure_singleton, exists_exists_eq_and]
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
N : Type u_5
inst✝¹ : Group N
C : Type u_6
inst✝ : CommGroup C
s t : Subgroup C
x✝ x y z : C
⊢ (∃ y_1 ∈ closure {x}, ∃ z_1 ∈ closure {y}, y_1 * z_1 = z) ↔ ∃ m n, x ^ m * y ^ n = z
state_after: no goals