tasksource/leandojo huggingface dataset:
Theorem: LieModule.nontrivial_lowerCentralSeriesLast
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: rw [LieSubmodule.nontrivial_iff_ne_bot, lowerCentralSeriesLast]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
k : ℕ
N : LieSubmodule R L M
inst✝¹ : Nontrivial M
inst✝ : IsNilpotent R L M
⊢ Nontrivial { x // x ∈ ↑(lowerCentralSeriesLast R L M) }

tactic: cases h : nilpotencyLength R L M
state_before: R : Type u
L : Type v
M : Type w
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
k : ℕ
N : LieSubmodule R L M
inst✝¹ : Nontrivial M
inst✝ : IsNilpotent R L M
⊢ (match nilpotencyLength R L M with
    | 0 => ⊥
    | Nat.succ k => lowerCentralSeries R L M k) ≠
    ⊥

tactic: rw [nilpotencyLength_eq_zero_iff, ← not_nontrivial_iff_subsingleton] at h
state_before: case zero
R : Type u
L : Type v
M : Type w
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
k : ℕ
N : LieSubmodule R L M
inst✝¹ : Nontrivial M
inst✝ : IsNilpotent R L M
h : nilpotencyLength R L M = Nat.zero
⊢ (match Nat.zero with
    | 0 => ⊥
    | Nat.succ k => lowerCentralSeries R L M k) ≠
    ⊥

tactic: contradiction
state_before: case zero
R : Type u
L : Type v
M : Type w
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
k : ℕ
N : LieSubmodule R L M
inst✝¹ : Nontrivial M
inst✝ : IsNilpotent R L M
h : ¬Nontrivial M
⊢ (match Nat.zero with
    | 0 => ⊥
    | Nat.succ k => lowerCentralSeries R L M k) ≠
    ⊥

tactic: rw [nilpotencyLength_eq_succ_iff] at h
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
k : ℕ
N : LieSubmodule R L M
inst✝¹ : Nontrivial M
inst✝ : IsNilpotent R L M
n✝ : ℕ
h : nilpotencyLength R L M = Nat.succ n✝
⊢ (match Nat.succ n✝ with
    | 0 => ⊥
    | Nat.succ k => lowerCentralSeries R L M k) ≠
    ⊥

tactic: exact h.2
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
k : ℕ
N : LieSubmodule R L M
inst✝¹ : Nontrivial M
inst✝ : IsNilpotent R L M
n✝ : ℕ
h : lowerCentralSeries R L M (n✝ + 1) = ⊥ ∧ lowerCentralSeries R L M n✝ ≠ ⊥
⊢ (match Nat.succ n✝ with
    | 0 => ⊥
    | Nat.succ k => lowerCentralSeries R L M k) ≠
    ⊥
Theorem: TensorPower.gradedMonoid_eq_of_cast
File: Mathlib/LinearAlgebra/TensorPower.lean

tactic: refine' gradedMonoid_eq_of_reindex_cast h _
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
a b : GradedMonoid fun n => ⨂[R] (x : Fin n), M
h : a.fst = b.fst
h2 : ↑(cast R M h) a.snd = b.snd
⊢ a = b

tactic: rw [cast] at h2
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
a b : GradedMonoid fun n => ⨂[R] (x : Fin n), M
h : a.fst = b.fst
h2 : ↑(cast R M h) a.snd = b.snd
⊢ ↑(reindex R M (Equiv.cast (_ : Fin a.fst = Fin b.fst))) a.snd = b.snd

tactic: rw [← Fin.cast_to_equiv, ← h2]
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
a b : GradedMonoid fun n => ⨂[R] (x : Fin n), M
h : a.fst = b.fst
h2 : ↑(reindex R M (Fin.cast h).toEquiv) a.snd = b.snd
⊢ ↑(reindex R M (Equiv.cast (_ : Fin a.fst = Fin b.fst))) a.snd = b.snd
Theorem: Complex.frontier_setOf_le_re_and_le_im
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [closure_Ici, frontier_Ici] using frontier_reProdIm (Ici a) (Ici b)
state_before: a b : ℝ
⊢ frontier {z | a ≤ z.re ∧ b ≤ z.im} = {z | a ≤ z.re ∧ z.im = b ∨ z.re = a ∧ b ≤ z.im}
Theorem: Multiset.toFinsupp_singleton
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.60610
ι : Type ?u.60613
a : α
⊢ {a} = ↑Finsupp.toMultiset (Finsupp.single a 1)
Theorem: IsROrC.inv_def
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rcases eq_or_ne z 0 with (rfl | h₀)
state_before: K : Type u_1
E : Type ?u.5349633
inst✝ : IsROrC K
z : K
⊢ z⁻¹ = ↑(starRingEnd K) z * ↑(‖z‖ ^ 2)⁻¹

tactic: simp
state_before: case inl
K : Type u_1
E : Type ?u.5349633
inst✝ : IsROrC K
⊢ 0⁻¹ = ↑(starRingEnd K) 0 * ↑(‖0‖ ^ 2)⁻¹

tactic: apply inv_eq_of_mul_eq_one_right
state_before: case inr
K : Type u_1
E : Type ?u.5349633
inst✝ : IsROrC K
z : K
h₀ : z ≠ 0
⊢ z⁻¹ = ↑(starRingEnd K) z * ↑(‖z‖ ^ 2)⁻¹

tactic: rw [← mul_assoc, mul_conj, ofReal_inv, ← normSq_eq_def', mul_inv_cancel]
state_before: case inr.a
K : Type u_1
E : Type ?u.5349633
inst✝ : IsROrC K
z : K
h₀ : z ≠ 0
⊢ z * (↑(starRingEnd K) z * ↑(‖z‖ ^ 2)⁻¹) = 1

tactic: rwa [ofReal_ne_zero, Ne.def, normSq_eq_zero]
state_before: case inr.a
K : Type u_1
E : Type ?u.5349633
inst✝ : IsROrC K
z : K
h₀ : z ≠ 0
⊢ ↑(↑normSq z) ≠ 0
Theorem: Ordinal.isClosed_iff_bsup
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: rw [isClosed_iff_sup]
state_before: s : Set Ordinal
a : Ordinal
⊢ IsClosed s ↔
    ∀ {o : Ordinal},
      o ≠ 0 → ∀ (f : (a : Ordinal) → a < o → Ordinal), (∀ (i : Ordinal) (hi : i < o), f i hi ∈ s) → bsup o f ∈ s

tactic: refine' ⟨fun H o ho f hf => H (out_nonempty_iff_ne_zero.2 ho) _ _, fun H ι hι f hf => _⟩
state_before: s : Set Ordinal
a : Ordinal
⊢ (∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal), (∀ (i : ι), f i ∈ s) → sup f ∈ s) ↔
    ∀ {o : Ordinal},
      o ≠ 0 → ∀ (f : (a : Ordinal) → a < o → Ordinal), (∀ (i : Ordinal) (hi : i < o), f i hi ∈ s) → bsup o f ∈ s

tactic: exact fun i => hf _ _
state_before: case refine'_1
s : Set Ordinal
a : Ordinal
H : ∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal), (∀ (i : ι), f i ∈ s) → sup f ∈ s
o : Ordinal
ho : o ≠ 0
f : (a : Ordinal) → a < o → Ordinal
hf : ∀ (i : Ordinal) (hi : i < o), f i hi ∈ s
⊢ ∀ (i : (Quotient.out o).α), familyOfBFamily o f i ∈ s

tactic: rw [← bsup_eq_sup]
state_before: case refine'_2
s : Set Ordinal
a : Ordinal
H :
  ∀ {o : Ordinal},
    o ≠ 0 → ∀ (f : (a : Ordinal) → a < o → Ordinal), (∀ (i : Ordinal) (hi : i < o), f i hi ∈ s) → bsup o f ∈ s
ι : Type u
hι : Nonempty ι
f : ι → Ordinal
hf : ∀ (i : ι), f i ∈ s
⊢ sup f ∈ s

tactic: apply H (type_ne_zero_iff_nonempty.2 hι)
state_before: case refine'_2
s : Set Ordinal
a : Ordinal
H :
  ∀ {o : Ordinal},
    o ≠ 0 → ∀ (f : (a : Ordinal) → a < o → Ordinal), (∀ (i : Ordinal) (hi : i < o), f i hi ∈ s) → bsup o f ∈ s
ι : Type u
hι : Nonempty ι
f : ι → Ordinal
hf : ∀ (i : ι), f i ∈ s
⊢ bsup (type WellOrderingRel) (bfamilyOfFamily f) ∈ s

tactic: exact fun i hi => hf _
state_before: case refine'_2.a
s : Set Ordinal
a : Ordinal
H :
  ∀ {o : Ordinal},
    o ≠ 0 → ∀ (f : (a : Ordinal) → a < o → Ordinal), (∀ (i : Ordinal) (hi : i < o), f i hi ∈ s) → bsup o f ∈ s
ι : Type u
hι : Nonempty ι
f : ι → Ordinal
hf : ∀ (i : ι), f i ∈ s
⊢ ∀ (i : Ordinal) (hi : i < type WellOrderingRel), bfamilyOfFamily f i hi ∈ s
Theorem: Bool.lt_iff
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ {x y : Bool}, x < y ↔ x = false ∧ y = true
Theorem: Multiset.dvd_prod
File: Mathlib/Algebra/BigOperators/Multiset/Lemmas.lean

tactic: simpa using List.dvd_prod h
state_before: α : Type u_1
inst✝ : CommMonoid α
s : Multiset α
a✝ : α
l : List α
a : α
h : a ∈ Quotient.mk (List.isSetoid α) l
⊢ a ∣ prod (Quotient.mk (List.isSetoid α) l)
Theorem: ciSup_le
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: rwa [forall_range_iff]
state_before: α : Type u_2
β : Type ?u.54850
γ : Type ?u.54853
ι : Sort u_1
inst✝¹ : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝ : Nonempty ι
f : ι → α
c : α
H : ∀ (x : ι), f x ≤ c
⊢ ∀ (b : α), b ∈ range f → b ≤ c
Theorem: Computation.terminates_congr
File: Mathlib/Data/Seq/Computation.lean

tactic: simp only [terminates_iff, exists_congr h]
state_before: α : Type u
β : Type v
γ : Type w
c₁ c₂ : Computation α
h : c₁ ~ c₂
⊢ Terminates c₁ ↔ Terminates c₂
Theorem: Multiset.powersetLen_mono
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp only [powersetLen_coe, coe_le]
state_before: α : Type u_1
n : ℕ
s t : Multiset α
h✝ : s ≤ t
l₁ l₂ : List α
h : l₁ <+ l₂
⊢ powersetLen n ↑l₁ ≤ powersetLen n ↑l₂

tactic: exact ((sublistsLen_sublist_of_sublist _ h).map _).subperm
state_before: α : Type u_1
n : ℕ
s t : Multiset α
h✝ : s ≤ t
l₁ l₂ : List α
h : l₁ <+ l₂
⊢ List.map ofList (sublistsLen n l₁) <+~ List.map ofList (sublistsLen n l₂)
Theorem: LinearEquiv.ofSubsingleton_self
File: Mathlib/Algebra/Module/Equiv.lean

tactic: ext
state_before: R : Type u_2
R₁ : Type ?u.342124
R₂ : Type ?u.342127
R₃ : Type ?u.342130
k : Type ?u.342133
S : Type ?u.342136
M : Type u_1
M₁ : Type ?u.342142
M₂ : Type ?u.342145
M₃ : Type ?u.342148
N₁ : Type ?u.342151
N₂ : Type ?u.342154
N₃ : Type ?u.342157
N₄ : Type ?u.342160
ι : Type ?u.342163
M₄ : Type ?u.342166
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring S
inst✝⁹ : Semiring R₁
inst✝⁸ : Semiring R₂
inst✝⁷ : Semiring R₃
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Subsingleton M
inst✝ : Subsingleton M₂
⊢ ofSubsingleton M M = refl R M

tactic: simp
state_before: case h
R : Type u_2
R₁ : Type ?u.342124
R₂ : Type ?u.342127
R₃ : Type ?u.342130
k : Type ?u.342133
S : Type ?u.342136
M : Type u_1
M₁ : Type ?u.342142
M₂ : Type ?u.342145
M₃ : Type ?u.342148
N₁ : Type ?u.342151
N₂ : Type ?u.342154
N₃ : Type ?u.342157
N₄ : Type ?u.342160
ι : Type ?u.342163
M₄ : Type ?u.342166
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring S
inst✝⁹ : Semiring R₁
inst✝⁸ : Semiring R₂
inst✝⁷ : Semiring R₃
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Subsingleton M
inst✝ : Subsingleton M₂
x✝ : M
⊢ ↑(ofSubsingleton M M) x✝ = ↑(refl R M) x✝
Theorem: LaurentPolynomial.reduce_to_polynomial_of_mul_T
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: induction' f using LaurentPolynomial.induction_on_mul_T with f n
state_before: R : Type u_1
inst✝ : Semiring R
f : R[T;T⁻¹]
Q : R[T;T⁻¹] → Prop
Qf : ∀ (f : R[X]), Q (↑toLaurent f)
QT : ∀ (f : R[T;T⁻¹]), Q (f * T 1) → Q f
⊢ Q f

tactic: induction' n with n hn
state_before: case Qf
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
Qf : ∀ (f : R[X]), Q (↑toLaurent f)
QT : ∀ (f : R[T;T⁻¹]), Q (f * T 1) → Q f
f : R[X]
n : ℕ
⊢ Q (↑toLaurent f * T (-↑n))

tactic: simpa only [Nat.zero_eq, Nat.cast_zero, neg_zero, T_zero, mul_one] using Qf _
state_before: case Qf.zero
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
Qf : ∀ (f : R[X]), Q (↑toLaurent f)
QT : ∀ (f : R[T;T⁻¹]), Q (f * T 1) → Q f
f : R[X]
⊢ Q (↑toLaurent f * T (-↑Nat.zero))

tactic: convert QT _ _
state_before: case Qf.succ
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
Qf : ∀ (f : R[X]), Q (↑toLaurent f)
QT : ∀ (f : R[T;T⁻¹]), Q (f * T 1) → Q f
f : R[X]
n : ℕ
hn : Q (↑toLaurent f * T (-↑n))
⊢ Q (↑toLaurent f * T (-↑(Nat.succ n)))

tactic: simpa using hn
state_before: case Qf.succ.convert_2
R : Type u_1
inst✝ : Semiring R
Q : R[T;T⁻¹] → Prop
Qf : ∀ (f : R[X]), Q (↑toLaurent f)
QT : ∀ (f : R[T;T⁻¹]), Q (f * T 1) → Q f
f : R[X]
n : ℕ
hn : Q (↑toLaurent f * T (-↑n))
⊢ Q (↑toLaurent f * T (-↑(Nat.succ n)) * T 1)
Theorem: Nat.two_mul
File: Std/Data/Nat/Lemmas.lean

tactic: simp [Nat.succ_mul]
state_before: n : Nat
⊢ 2 * n = n + n
Theorem: Finset.card_doubleton
File: Mathlib/Data/Finset/Card.lean

tactic: rw [card_insert_of_not_mem (not_mem_singleton.2 h), card_singleton]
state_before: α : Type u_1
β : Type ?u.5726
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : a ≠ b
⊢ card {a, b} = 2
Theorem: PowerSeries.coeff_succ_mul_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp only [coeff, Finsupp.single_add]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : PowerSeries R
⊢ ↑(coeff R (n + 1)) (φ * X) = ↑(coeff R n) φ

tactic: convert φ.coeff_add_mul_monomial (single () n) (single () 1) _
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : PowerSeries R
⊢ ↑(MvPowerSeries.coeff R (single () n + single () 1)) (φ * X) = ↑(MvPowerSeries.coeff R (single () n)) φ

tactic: rw [mul_one]
state_before: case h.e'_3
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : PowerSeries R
⊢ ↑(MvPowerSeries.coeff R (single () n)) φ = ↑(MvPowerSeries.coeff R (single () n)) φ * 1
Theorem: Real.log_nonneg_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [← not_lt, log_neg_iff hx, not_lt]
state_before: x y : ℝ
hx : 0 < x
⊢ 0 ≤ log x ↔ 1 ≤ x
Theorem: norm_pow_le'
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simpa only [NNReal.coe_pow, coe_nnnorm] using NNReal.coe_mono (nnnorm_pow_le' a h)
state_before: α : Type u_1
β : Type ?u.131699
γ : Type ?u.131702
ι : Type ?u.131705
inst✝ : SeminormedRing α
a : α
n : ℕ
h : 0 < n
⊢ ‖a ^ n‖ ≤ ‖a‖ ^ n
Theorem: Set.indicator_smul_apply
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: dsimp only [indicator]
state_before: α : Type u_1
β : Type ?u.76600
ι : Type ?u.76603
M : Type u_3
N : Type ?u.76609
A : Type u_2
inst✝² : AddMonoid A
inst✝¹ : Monoid M
inst✝ : DistribMulAction M A
s : Set α
r : α → M
f : α → A
x : α
⊢ indicator s (fun x => r x • f x) x = r x • indicator s f x

tactic: split_ifs
state_before: α : Type u_1
β : Type ?u.76600
ι : Type ?u.76603
M : Type u_3
N : Type ?u.76609
A : Type u_2
inst✝² : AddMonoid A
inst✝¹ : Monoid M
inst✝ : DistribMulAction M A
s : Set α
r : α → M
f : α → A
x : α
⊢ (if x ∈ s then r x • f x else 0) = r x • if x ∈ s then f x else 0

tactic: exacts [rfl, (smul_zero (r x)).symm]
state_before: case inl
α : Type u_1
β : Type ?u.76600
ι : Type ?u.76603
M : Type u_3
N : Type ?u.76609
A : Type u_2
inst✝² : AddMonoid A
inst✝¹ : Monoid M
inst✝ : DistribMulAction M A
s : Set α
r : α → M
f : α → A
x : α
h✝ : x ∈ s
⊢ r x • f x = r x • f x

case inr
α : Type u_1
β : Type ?u.76600
ι : Type ?u.76603
M : Type u_3
N : Type ?u.76609
A : Type u_2
inst✝² : AddMonoid A
inst✝¹ : Monoid M
inst✝ : DistribMulAction M A
s : Set α
r : α → M
f : α → A
x : α
h✝ : ¬x ∈ s
⊢ 0 = r x • 0
Theorem: Multiset.mem_sigma
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [Multiset.sigma, and_assoc, and_left_comm]
state_before: α : Type u_1
β : Type ?u.73832
γ : Type ?u.73835
δ : Type ?u.73838
σ : α → Type u_2
a✝ : α
s✝ : Multiset α
t✝ : (a : α) → Multiset (σ a)
s : Multiset α
t : (a : α) → Multiset (σ a)
a : α
b : σ a
⊢ { fst := a, snd := b } ∈ Multiset.sigma s t ↔
    { fst := a, snd := b }.fst ∈ s ∧ { fst := a, snd := b }.snd ∈ t { fst := a, snd := b }.fst
Theorem: MeasureTheory.AEDisjoint.union_right_iff
File: Mathlib/MeasureTheory/Measure/AEDisjoint.lean

tactic: simp [union_eq_iUnion, and_comm]
state_before: ι : Type ?u.7705
α : Type u_1
m : MeasurableSpace α
μ : Measure α
s t u v : Set α
⊢ AEDisjoint μ s (t ∪ u) ↔ AEDisjoint μ s t ∧ AEDisjoint μ s u
Theorem: Subgroup.index_iInf_ne_zero
File: Mathlib/GroupTheory/Index.lean

tactic: simp_rw [← relindex_top_right] at hf⊢
state_before: G : Type u_2
inst✝¹ : Group G
H K L : Subgroup G
ι : Type u_1
inst✝ : Finite ι
f : ι → Subgroup G
hf : ∀ (i : ι), index (f i) ≠ 0
⊢ index (⨅ (i : ι), f i) ≠ 0

tactic: exact relindex_iInf_ne_zero hf
state_before: G : Type u_2
inst✝¹ : Group G
H K L : Subgroup G
ι : Type u_1
inst✝ : Finite ι
f : ι → Subgroup G
hf : ∀ (i : ι), relindex (f i) ⊤ ≠ 0
⊢ relindex (⨅ (i : ι), f i) ⊤ ≠ 0
Theorem: List.nodup_ofFn
File: Mathlib/Data/List/FinRange.lean

tactic: refine' ⟨_, nodup_ofFn_ofInjective⟩
state_before: α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
⊢ Nodup (ofFn f) ↔ Function.Injective f

tactic: refine' Fin.consInduction _ (fun x₀ xs ih => _) f
state_before: α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
⊢ Nodup (ofFn f) → Function.Injective f

tactic: intro _
state_before: case refine'_1
α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
⊢ Nodup (ofFn Fin.elim0) → Function.Injective Fin.elim0

tactic: exact Function.injective_of_subsingleton _
state_before: case refine'_1
α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
a✝ : Nodup (ofFn Fin.elim0)
⊢ Function.Injective Fin.elim0

tactic: intro h
state_before: case refine'_2
α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
n✝ : ℕ
x₀ : α
xs : Fin n✝ → α
ih : Nodup (ofFn xs) → Function.Injective xs
⊢ Nodup (ofFn (Fin.cons x₀ xs)) → Function.Injective (Fin.cons x₀ xs)

tactic: rw [Fin.cons_injective_iff]
state_before: case refine'_2
α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
n✝ : ℕ
x₀ : α
xs : Fin n✝ → α
ih : Nodup (ofFn xs) → Function.Injective xs
h : Nodup (ofFn (Fin.cons x₀ xs))
⊢ Function.Injective (Fin.cons x₀ xs)

tactic: simp_rw [ofFn_succ, Fin.cons_succ, nodup_cons, Fin.cons_zero, mem_ofFn] at h
state_before: case refine'_2
α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
n✝ : ℕ
x₀ : α
xs : Fin n✝ → α
ih : Nodup (ofFn xs) → Function.Injective xs
h : Nodup (ofFn (Fin.cons x₀ xs))
⊢ ¬x₀ ∈ Set.range xs ∧ Function.Injective xs

tactic: exact h.imp_right ih
state_before: case refine'_2
α✝ : Type u
α : Type u_1
n : ℕ
f : Fin n → α
n✝ : ℕ
x₀ : α
xs : Fin n✝ → α
ih : Nodup (ofFn xs) → Function.Injective xs
h : (¬x₀ ∈ Set.range fun i => xs i) ∧ Nodup (ofFn fun i => xs i)
⊢ ¬x₀ ∈ Set.range xs ∧ Function.Injective xs
Theorem: tendsto_norm'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa using tendsto_id.dist (tendsto_const_nhds : Tendsto (fun _a => (1 : E)) _ _)
state_before: 𝓕 : Type ?u.457116
𝕜 : Type ?u.457119
α : Type ?u.457122
ι : Type ?u.457125
κ : Type ?u.457128
E : Type u_1
F : Type ?u.457134
G : Type ?u.457137
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
x : E
⊢ Tendsto (fun a => ‖a‖) (𝓝 x) (𝓝 ‖x‖)
Theorem: CategoryTheory.Idempotents.isIdempotentComplete_iff_of_equivalence
File: Mathlib/CategoryTheory/Idempotents/Basic.lean

tactic: constructor
state_before: C : Type u_4
inst✝¹ : Category C
D : Type u_1
inst✝ : Category D
ε : C ≌ D
⊢ IsIdempotentComplete C ↔ IsIdempotentComplete D

tactic: exact Equivalence.isIdempotentComplete ε
state_before: case mp
C : Type u_4
inst✝¹ : Category C
D : Type u_1
inst✝ : Category D
ε : C ≌ D
⊢ IsIdempotentComplete C → IsIdempotentComplete D

tactic: exact Equivalence.isIdempotentComplete ε.symm
state_before: case mpr
C : Type u_4
inst✝¹ : Category C
D : Type u_1
inst✝ : Category D
ε : C ≌ D
⊢ IsIdempotentComplete D → IsIdempotentComplete C
Theorem: Function.LeftInverse.eq_rightInverse
File: Mathlib/Logic/Function/Basic.lean

tactic: rw [h₂.comp_eq_id, comp.right_id]
state_before: α : Sort u_1
β : Sort u_2
γ : Sort ?u.12071
f✝ f : α → β
g₁ g₂ : β → α
h₁ : LeftInverse g₁ f
h₂ : RightInverse g₂ f
⊢ g₁ = g₁ ∘ f ∘ g₂

tactic: rw [← comp.assoc, h₁.comp_eq_id, comp.left_id]
state_before: α : Sort u_1
β : Sort u_2
γ : Sort ?u.12071
f✝ f : α → β
g₁ g₂ : β → α
h₁ : LeftInverse g₁ f
h₂ : RightInverse g₂ f
⊢ g₁ ∘ f ∘ g₂ = g₂
Theorem: CategoryTheory.Limits.cokernelZeroIsoTarget_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasCokernel f
⊢ 0 ≫ 𝟙 Y = 0

tactic: apply coequalizer.hom_ext
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasCokernel f
⊢ cokernelZeroIsoTarget.hom = cokernel.desc 0 (𝟙 Y) (_ : 0 ≫ 𝟙 Y = 0)

tactic: simp [cokernelZeroIsoTarget]
state_before: case h
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasCokernel f
⊢ coequalizer.π 0 0 ≫ cokernelZeroIsoTarget.hom = coequalizer.π 0 0 ≫ cokernel.desc 0 (𝟙 Y) (_ : 0 ≫ 𝟙 Y = 0)
Theorem: Set.SurjOn.bijOn_subset
File: Mathlib/Data/Set/Function.lean

tactic: refine' h.invOn_invFunOn.bijOn _ (mapsTo_image _ _)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.67762
ι : Sort ?u.67765
π : α → Type ?u.67770
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
⊢ BijOn f (invFunOn f s '' t) t

tactic: rintro _ ⟨y, hy, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.67762
ι : Sort ?u.67765
π : α → Type ?u.67770
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
⊢ MapsTo f (invFunOn f s '' t) t

tactic: rwa [h.rightInvOn_invFunOn hy]
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.67762
ι : Sort ?u.67765
π : α → Type ?u.67770
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : SurjOn f s t
y : β
hy : y ∈ t
⊢ f (invFunOn f s y) ∈ t
Theorem: List.mem_of_mem_remove
File: Mathlib/Data/List/Card.lean

tactic: rw [mem_remove_iff] at h
state_before: α : Type u_1
β : Sort ?u.19844
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a b : α
as : List α
h : b ∈ remove a as
⊢ b ∈ as

tactic: exact h.1
state_before: α : Type u_1
β : Sort ?u.19844
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a b : α
as : List α
h : b ∈ as ∧ b ≠ a
⊢ b ∈ as
Theorem: div_eq_div_iff_mul_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_iff_eq_mul, div_mul_eq_mul_div, eq_comm, div_eq_iff_eq_mul']
state_before: α : Type ?u.75037
β : Type ?u.75040
G : Type u_1
inst✝ : CommGroup G
a b c d : G
⊢ a / b = c / d ↔ a * d = c * b

tactic: simp only [mul_comm, eq_comm]
state_before: α : Type ?u.75037
β : Type ?u.75040
G : Type u_1
inst✝ : CommGroup G
a b c d : G
⊢ c * b = d * a ↔ a * d = c * b
Theorem: RatFunc.eval_algebraMap
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simp [eval, IsScalarTower.algebraMap_apply S K[X] (RatFunc K)]
state_before: K : Type u
inst✝³ : Field K
L : Type u_2
inst✝² : Field L
f : K →+* L
a : L
S : Type u_1
inst✝¹ : CommSemiring S
inst✝ : Algebra S K[X]
p : S
⊢ eval f a (↑(algebraMap S (RatFunc K)) p) = Polynomial.eval₂ f a (↑(algebraMap S K[X]) p)
Theorem: Finsupp.single_apply_ne_zero
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp [single_apply_eq_zero]
state_before: α : Type u_2
β : Type ?u.51375
γ : Type ?u.51378
ι : Type ?u.51381
M : Type u_1
M' : Type ?u.51387
N : Type ?u.51390
P : Type ?u.51393
G : Type ?u.51396
H : Type ?u.51399
R : Type ?u.51402
S : Type ?u.51405
inst✝ : Zero M
a✝ a' : α
b✝ : M
a x : α
b : M
⊢ ↑(single a b) x ≠ 0 ↔ x = a ∧ b ≠ 0
Theorem: List.foldl_range_subset_of_range_subset
File: Mathlib/Data/List/Lemmas.lean

tactic: change (Set.range fun l => _) ⊆ Set.range fun l => _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β → α
g : α → γ → α
hfg : (Set.range fun a c => f c a) ⊆ Set.range fun b c => g c b
a : α
⊢ Set.range (foldl f a) ⊆ Set.range (foldl g a)

tactic: simp_rw [← foldr_reverse _ (fun z w => g w z), ← foldr_reverse _ (fun z w => f w z)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β → α
g : α → γ → α
hfg : (Set.range fun a c => f c a) ⊆ Set.range fun b c => g c b
a : α
⊢ (Set.range fun l => foldl f a l) ⊆ Set.range fun l => foldl g a l

tactic: change (Set.range (foldr (fun z w => f w z) a ∘ reverse)) ⊆
  Set.range (foldr (fun z w => g w z) a ∘ reverse)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β → α
g : α → γ → α
hfg : (Set.range fun a c => f c a) ⊆ Set.range fun b c => g c b
a : α
⊢ (Set.range fun l => foldr (fun z w => f w z) a (reverse l)) ⊆
    Set.range fun l => foldr (fun z w => g w z) a (reverse l)

tactic: simp_rw [Set.range_comp _ reverse, reverse_involutive.bijective.surjective.range_eq,
  Set.image_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β → α
g : α → γ → α
hfg : (Set.range fun a c => f c a) ⊆ Set.range fun b c => g c b
a : α
⊢ Set.range (foldr (fun z w => f w z) a ∘ reverse) ⊆ Set.range (foldr (fun z w => g w z) a ∘ reverse)

tactic: exact foldr_range_subset_of_range_subset hfg a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β → α
g : α → γ → α
hfg : (Set.range fun a c => f c a) ⊆ Set.range fun b c => g c b
a : α
⊢ Set.range (foldr (fun z w => f w z) a) ⊆ Set.range (foldr (fun z w => g w z) a)