tasksource/leandojo huggingface dataset:
Theorem: Quotient.ind₂
File: src/lean/Init/Core.lean

tactic: induction q₁ using Quotient.ind
state_before: a b c d : Prop
α : Sort uA
β : Sort uB
φ : Sort uC
s₁ : Setoid α
s₂ : Setoid β
motive : Quotient s₁ → Quotient s₂ → Prop
h : ∀ (a : α) (b : β), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b)
q₁ : Quotient s₁
q₂ : Quotient s₂
⊢ motive q₁ q₂

tactic: induction q₂ using Quotient.ind
state_before: case a
a b c d : Prop
α : Sort uA
β : Sort uB
φ : Sort uC
s₁ : Setoid α
s₂ : Setoid β
motive : Quotient s₁ → Quotient s₂ → Prop
h : ∀ (a : α) (b : β), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b)
q₂ : Quotient s₂
a✝ : α
⊢ motive (Quotient.mk s₁ a✝) q₂

tactic: apply h
state_before: case a.a
a b c d : Prop
α : Sort uA
β : Sort uB
φ : Sort uC
s₁ : Setoid α
s₂ : Setoid β
motive : Quotient s₁ → Quotient s₂ → Prop
h : ∀ (a : α) (b : β), motive (Quotient.mk s₁ a) (Quotient.mk s₂ b)
a✝¹ : α
a✝ : β
⊢ motive (Quotient.mk s₁ a✝¹) (Quotient.mk s₂ a✝)
Theorem: Colex.empty_toColex_lt
File: Mathlib/Combinatorics/Colex.lean

tactic: rw [Colex.lt_def]
state_before: α : Type u_1
inst✝ : LinearOrder α
A : Finset α
hA : Finset.Nonempty A
⊢ toColex ∅ < toColex A

tactic: refine' ⟨max' _ hA, _, by simp, max'_mem _ _⟩
state_before: α : Type u_1
inst✝ : LinearOrder α
A : Finset α
hA : Finset.Nonempty A
⊢ ∃ k, (∀ {x : α}, k < x → (x ∈ ∅ ↔ x ∈ A)) ∧ ¬k ∈ ∅ ∧ k ∈ A

tactic: simp only [false_iff_iff, not_mem_empty]
state_before: α : Type u_1
inst✝ : LinearOrder α
A : Finset α
hA : Finset.Nonempty A
⊢ ∀ {x : α}, max' A hA < x → (x ∈ ∅ ↔ x ∈ A)

tactic: intro x hx t
state_before: α : Type u_1
inst✝ : LinearOrder α
A : Finset α
hA : Finset.Nonempty A
⊢ ∀ {x : α}, max' A hA < x → ¬x ∈ A

tactic: apply not_le_of_lt hx (le_max' _ _ t)
state_before: α : Type u_1
inst✝ : LinearOrder α
A : Finset α
hA : Finset.Nonempty A
x : α
hx : max' A hA < x
t : x ∈ A
⊢ False

tactic: simp
state_before: α : Type u_1
inst✝ : LinearOrder α
A : Finset α
hA : Finset.Nonempty A
⊢ ¬max' A hA ∈ ∅
Theorem: AffineSubspace.wSameSide_of_left_mem
File: Mathlib/Analysis/Convex/Side.lean

tactic: refine' ⟨x, hx, x, hx, _⟩
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.114846
P : Type u_3
P' : Type ?u.114852
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
hx : x ∈ s
⊢ WSameSide s x y

tactic: rw [vsub_self]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.114846
P : Type u_3
P' : Type ?u.114852
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
hx : x ∈ s
⊢ SameRay R (x -ᵥ x) (y -ᵥ x)

tactic: apply SameRay.zero_left
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.114846
P : Type u_3
P' : Type ?u.114852
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
hx : x ∈ s
⊢ SameRay R 0 (y -ᵥ x)
Theorem: IsPGroup.iff_card
File: Mathlib/GroupTheory/PGroup.lean

tactic: have hG : card G ≠ 0 := card_ne_zero
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype G
⊢ IsPGroup p G ↔ ∃ n, card G = p ^ n

tactic: refine' ⟨fun h => _, fun ⟨n, hn⟩ => of_card hn⟩
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype G
hG : card G ≠ 0
⊢ IsPGroup p G ↔ ∃ n, card G = p ^ n

tactic: suffices ∀ q ∈ Nat.factors (card G), q = p by
  use (card G).factors.length
  rw [← List.prod_replicate, ← List.eq_replicate_of_mem this, Nat.prod_factors hG]
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype G
hG : card G ≠ 0
h : IsPGroup p G
⊢ ∃ n, card G = p ^ n

tactic: intro q hq
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype G
hG : card G ≠ 0
h : IsPGroup p G
⊢ ∀ (q : ℕ), q ∈ Nat.factors (card G) → q = p

tactic: obtain ⟨hq1, hq2⟩ := (Nat.mem_factors hG).mp hq
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype G
hG : card G ≠ 0
h : IsPGroup p G
q : ℕ
hq : q ∈ Nat.factors (card G)
⊢ q = p

tactic: haveI : Fact q.Prime := ⟨hq1⟩
state_before: case intro
p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype G
hG : card G ≠ 0
h : IsPGroup p G
q : ℕ
hq : q ∈ Nat.factors (card G)
hq1 : Nat.Prime q
hq2 : q ∣ card G
⊢ q = p

tactic: obtain ⟨g, hg⟩ := exists_prime_orderOf_dvd_card q hq2
state_before: case intro
p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype G
hG : card G ≠ 0
h : IsPGroup p G
q : ℕ
hq : q ∈ Nat.factors (card G)
hq1 : Nat.Prime q
hq2 : q ∣ card G
this : Fact (Nat.Prime q)
⊢ q = p

tactic: obtain ⟨k, hk⟩ := (iff_orderOf.mp h) g
state_before: case intro.intro
p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype G
hG : card G ≠ 0
h : IsPGroup p G
q : ℕ
hq : q ∈ Nat.factors (card G)
hq1 : Nat.Prime q
hq2 : q ∣ card G
this : Fact (Nat.Prime q)
g : G
hg : orderOf g = q
⊢ q = p

tactic: exact (hq1.pow_eq_iff.mp (hg.symm.trans hk).symm).1.symm
state_before: case intro.intro.intro
p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype G
hG : card G ≠ 0
h : IsPGroup p G
q : ℕ
hq : q ∈ Nat.factors (card G)
hq1 : Nat.Prime q
hq2 : q ∣ card G
this : Fact (Nat.Prime q)
g : G
hg : orderOf g = q
k : ℕ
hk : orderOf g = p ^ k
⊢ q = p

tactic: use (card G).factors.length
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype G
hG : card G ≠ 0
h : IsPGroup p G
this : ∀ (q : ℕ), q ∈ Nat.factors (card G) → q = p
⊢ ∃ n, card G = p ^ n

tactic: rw [← List.prod_replicate, ← List.eq_replicate_of_mem this, Nat.prod_factors hG]
state_before: p : ℕ
G : Type u_1
inst✝² : Group G
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fintype G
hG : card G ≠ 0
h : IsPGroup p G
this : ∀ (q : ℕ), q ∈ Nat.factors (card G) → q = p
⊢ card G = p ^ List.length (Nat.factors (card G))
Theorem: ENNReal.toReal_le_toReal
File: Mathlib/Data/Real/ENNReal.lean

tactic: lift a to ℝ≥0 using ha
state_before: α : Type ?u.795291
β : Type ?u.795294
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ ⊤
⊢ ENNReal.toReal a ≤ ENNReal.toReal b ↔ a ≤ b

tactic: lift b to ℝ≥0 using hb
state_before: case intro
α : Type ?u.795291
β : Type ?u.795294
b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
a : ℝ≥0
⊢ ENNReal.toReal ↑a ≤ ENNReal.toReal b ↔ ↑a ≤ b

tactic: norm_cast
state_before: case intro.intro
α : Type ?u.795291
β : Type ?u.795294
c d : ℝ≥0∞
r p q a b : ℝ≥0
⊢ ENNReal.toReal ↑a ≤ ENNReal.toReal ↑b ↔ ↑a ≤ ↑b
Theorem: CategoryTheory.Limits.CompleteLattice.finite_coproduct_eq_finset_sup
File: Mathlib/CategoryTheory/Limits/Lattice.lean

tactic: trans
state_before: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ (∐ f) = Finset.sup Fintype.elems f

tactic: exact
  (IsColimit.coconePointUniqueUpToIso (colimit.isColimit _)
      (finiteColimitCocone (Discrete.functor f)).isColimit).to_eq
state_before: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ (∐ f) = ?m.37163

α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ ?m.37163 = Finset.sup Fintype.elems f

α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ α

tactic: change Finset.univ.sup (f ∘ discreteEquiv.toEmbedding) = Fintype.elems.sup f
state_before: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ (finiteColimitCocone (Discrete.functor f)).cocone.pt = Finset.sup Fintype.elems f

tactic: simp only [← Finset.sup_map, Finset.univ_map_equiv_to_embedding]
state_before: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ Finset.sup Finset.univ (f ∘ ↑(Equiv.toEmbedding discreteEquiv)) = Finset.sup Fintype.elems f

tactic: rfl
state_before: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ Finset.sup Finset.univ f = Finset.sup Fintype.elems f
Theorem: UniformEquiv.comap_eq
File: Mathlib/Topology/UniformSpace/Equiv.lean

tactic: ext : 1
state_before: α : Type u
β : Type u_1
γ : Type ?u.419491
δ : Type ?u.419494
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : UniformSpace δ
h : α ≃ᵤ β
⊢ UniformSpace.comap (↑h) inst✝² = inst✝³

tactic: exact h.uniformInducing.comap_uniformity
state_before: case a
α : Type u
β : Type u_1
γ : Type ?u.419491
δ : Type ?u.419494
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : UniformSpace δ
h : α ≃ᵤ β
⊢ uniformity α = uniformity α
Theorem: one_div_pow_lt_one_div_pow_of_lt
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: refine' (one_div_lt_one_div _ _).mpr (pow_lt_pow a1 mn) <;> exact pow_pos (zero_lt_one.trans a1) _
state_before: ι : Type ?u.123201
α : Type u_1
β : Type ?u.123207
inst✝ : LinearOrderedSemifield α
a b c d e : α
m✝ n✝ : ℤ
a1 : 1 < a
m n : ℕ
mn : m < n
⊢ 1 / a ^ n < 1 / a ^ m
Theorem: Nat.cast_div_div_div_cancel_right
File: Mathlib/Data/Nat/Cast/Field.lean

tactic: rcases eq_or_ne d 0 with (rfl | hd)
state_before: α : Type u_1
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
m n d : ℕ
hn : d ∣ n
hm : d ∣ m
⊢ ↑(m / d) / ↑(n / d) = ↑m / ↑n

tactic: replace hd : (d : α) ≠ 0
state_before: case inr
α : Type u_1
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
m n d : ℕ
hn : d ∣ n
hm : d ∣ m
hd : d ≠ 0
⊢ ↑(m / d) / ↑(n / d) = ↑m / ↑n

tactic: rw [cast_div hm, cast_div hn, div_div_div_cancel_right _ hd] <;> exact hd
state_before: case inr
α : Type u_1
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
m n d : ℕ
hn : d ∣ n
hm : d ∣ m
hd : ↑d ≠ 0
⊢ ↑(m / d) / ↑(n / d) = ↑m / ↑n

tactic: simp [zero_dvd_iff.mp hm]
state_before: case inl
α : Type u_1
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
m n : ℕ
hn : 0 ∣ n
hm : 0 ∣ m
⊢ ↑(m / 0) / ↑(n / 0) = ↑m / ↑n

tactic: norm_cast
state_before: case hd
α : Type u_1
inst✝¹ : DivisionSemiring α
inst✝ : CharZero α
m n d : ℕ
hn : d ∣ n
hm : d ∣ m
hd : d ≠ 0
⊢ ↑d ≠ 0
Theorem: Polynomial.eval₂_reflect_mul_pow
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: refine'
  induction_with_natDegree_le (fun f => eval₂ i (⅟ x) (reflect N f) * x ^ N = eval₂ i x f) _ _ _
    _ f hf
state_before: R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
⊢ eval₂ i (⅟x) (reflect N f) * x ^ N = eval₂ i x f

tactic: simp
state_before: case refine'_1
R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
⊢ (fun f => eval₂ i (⅟x) (reflect N f) * x ^ N = eval₂ i x f) 0

tactic: intro n r _ hnN
state_before: case refine'_2
R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
⊢ ∀ (n : ℕ) (r : R), r ≠ 0 → n ≤ N → (fun f => eval₂ i (⅟x) (reflect N f) * x ^ N = eval₂ i x f) (↑C r * X ^ n)

tactic: simp only [revAt_le hnN, reflect_C_mul_X_pow, eval₂_X_pow, eval₂_C, eval₂_mul]
state_before: case refine'_2
R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
n : ℕ
r : R
a✝ : r ≠ 0
hnN : n ≤ N
⊢ eval₂ i (⅟x) (reflect N (↑C r * X ^ n)) * x ^ N = eval₂ i x (↑C r * X ^ n)

tactic: conv in x ^ N => rw [← Nat.sub_add_cancel hnN]
state_before: case refine'_2
R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
n : ℕ
r : R
a✝ : r ≠ 0
hnN : n ≤ N
⊢ ↑i r * ⅟x ^ (N - n) * x ^ N = ↑i r * x ^ n

tactic: rw [pow_add, ← mul_assoc, mul_assoc (i r), ← mul_pow, invOf_mul_self, one_pow, mul_one]
state_before: case refine'_2
R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
n : ℕ
r : R
a✝ : r ≠ 0
hnN : n ≤ N
⊢ ↑i r * ⅟x ^ (N - n) * x ^ (N - n + n) = ↑i r * x ^ n

tactic: intros
state_before: case refine'_3
R : Type u_1
inst✝² : Semiring R
f✝ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
⊢ ∀ (f g : R[X]),
    natDegree f < natDegree g →
      natDegree g ≤ N →
        (fun f => eval₂ i (⅟x) (reflect N f) * x ^ N = eval₂ i x f) f →
          (fun f => eval₂ i (⅟x) (reflect N f) * x ^ N = eval₂ i x f) g →
            (fun f => eval₂ i (⅟x) (reflect N f) * x ^ N = eval₂ i x f) (f + g)

tactic: simp [*, add_mul]
state_before: case refine'_3
R : Type u_1
inst✝² : Semiring R
f✝¹ : R[X]
S : Type u_2
inst✝¹ : CommSemiring S
i : R →+* S
x : S
inst✝ : Invertible x
N : ℕ
f : R[X]
hf : natDegree f ≤ N
f✝ g✝ : R[X]
a✝³ : natDegree f✝ < natDegree g✝
a✝² : natDegree g✝ ≤ N
a✝¹ : eval₂ i (⅟x) (reflect N f✝) * x ^ N = eval₂ i x f✝
a✝ : eval₂ i (⅟x) (reflect N g✝) * x ^ N = eval₂ i x g✝
⊢ eval₂ i (⅟x) (reflect N (f✝ + g✝)) * x ^ N = eval₂ i x (f✝ + g✝)
Theorem: Submonoid.LocalizationMap.eq_mk'_iff_mul_eq
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [H, mk'_spec]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.784401
inst✝ : CommMonoid P
f : LocalizationMap S N
x : M
y : { x // x ∈ S }
z : N
H : z = mk' f x y
⊢ z * ↑(toMap f) ↑y = ↑(toMap f) x

tactic: erw [mul_inv_right, H]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.784401
inst✝ : CommMonoid P
f : LocalizationMap S N
x : M
y : { x // x ∈ S }
z : N
H : z * ↑(toMap f) ↑y = ↑(toMap f) x
⊢ z = mk' f x y
Theorem: Ideal.finite_mulSupport_coe
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

tactic: rw [mulSupport]
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ Set.Finite
    (mulSupport fun v =>
      ↑v.asIdeal ^ ↑(Associates.count (Associates.mk v.asIdeal) (Associates.factors (Associates.mk I))))

tactic: simp_rw [Ne.def, zpow_ofNat, ← FractionalIdeal.coeIdeal_pow, FractionalIdeal.coeIdeal_eq_one]
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ Set.Finite {x | ↑x.asIdeal ^ ↑(Associates.count (Associates.mk x.asIdeal) (Associates.factors (Associates.mk I))) ≠ 1}

tactic: exact finite_mulSupport hI
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
hI : I ≠ 0
⊢ Set.Finite {x | ¬x.asIdeal ^ Associates.count (Associates.mk x.asIdeal) (Associates.factors (Associates.mk I)) = 1}
Theorem: Nat.mul_div_right
File: Std/Data/Nat/Lemmas.lean

tactic: induction n <;> simp_all [mul_succ]
state_before: n m : Nat
H : 0 < m
⊢ m * n / m = n
Theorem: Finsupp.zero_update
File: Mathlib/Data/Finsupp/Defs.lean

tactic: classical
  ext
  rw [single_eq_update]
  rfl
state_before: α : Type u_1
β : Type ?u.149402
γ : Type ?u.149405
ι : Type ?u.149408
M : Type u_2
M' : Type ?u.149414
N : Type ?u.149417
P : Type ?u.149420
G : Type ?u.149423
H : Type ?u.149426
R : Type ?u.149429
S : Type ?u.149432
inst✝ : Zero M
f : α →₀ M
a : α
b : M
i : α
⊢ update 0 a b = single a b

tactic: ext
state_before: α : Type u_1
β : Type ?u.149402
γ : Type ?u.149405
ι : Type ?u.149408
M : Type u_2
M' : Type ?u.149414
N : Type ?u.149417
P : Type ?u.149420
G : Type ?u.149423
H : Type ?u.149426
R : Type ?u.149429
S : Type ?u.149432
inst✝ : Zero M
f : α →₀ M
a : α
b : M
i : α
⊢ update 0 a b = single a b

tactic: rw [single_eq_update]
state_before: case h
α : Type u_1
β : Type ?u.149402
γ : Type ?u.149405
ι : Type ?u.149408
M : Type u_2
M' : Type ?u.149414
N : Type ?u.149417
P : Type ?u.149420
G : Type ?u.149423
H : Type ?u.149426
R : Type ?u.149429
S : Type ?u.149432
inst✝ : Zero M
f : α →₀ M
a : α
b : M
i a✝ : α
⊢ ↑(update 0 a b) a✝ = ↑(single a b) a✝

tactic: rfl
state_before: case h
α : Type u_1
β : Type ?u.149402
γ : Type ?u.149405
ι : Type ?u.149408
M : Type u_2
M' : Type ?u.149414
N : Type ?u.149417
P : Type ?u.149420
G : Type ?u.149423
H : Type ?u.149426
R : Type ?u.149429
S : Type ?u.149432
inst✝ : Zero M
f : α →₀ M
a : α
b : M
i a✝ : α
⊢ ↑(update 0 a b) a✝ = Function.update 0 a b a✝
Theorem: FiniteDimensional.finrank_tensorProduct
File: Mathlib/LinearAlgebra/FreeModule/Finite/Rank.lean

tactic: simp [finrank]
state_before: R : Type u
M✝ : Type v
N✝ : Type w
inst✝¹⁵ : CommRing R
inst✝¹⁴ : StrongRankCondition R
inst✝¹³ : AddCommGroup M✝
inst✝¹² : Module R M✝
inst✝¹¹ : Module.Free R M✝
inst✝¹⁰ : Module.Finite R M✝
inst✝⁹ : AddCommGroup N✝
inst✝⁸ : Module R N✝
inst✝⁷ : Module.Free R N✝
inst✝⁶ : Module.Finite R N✝
M : Type v
N : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : Module.Free R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Free R N
⊢ finrank R (M ⊗[R] N) = finrank R M * finrank R N
Theorem: Fin.le_castSucc_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: simpa [lt_iff_val_lt_val, le_iff_val_le_val] using Nat.succ_le_succ_iff.symm
state_before: n m : ℕ
i : Fin (n + 1)
j : Fin n
⊢ i ≤ ↑castSucc j ↔ i < succ j
Theorem: subset_interior_iff_isOpen
File: Mathlib/Topology/Basic.lean

tactic: simp only [interior_eq_iff_isOpen.symm, Subset.antisymm_iff, interior_subset, true_and]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ s ⊆ interior s ↔ IsOpen s
Theorem: ENNReal.div_zero
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp [div_eq_mul_inv, h]
state_before: α : Type ?u.220554
β : Type ?u.220557
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≠ 0
⊢ a / 0 = ⊤
Theorem: CoheytingHom.cancel_left
File: Mathlib/Order/Heyting/Hom.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.116541
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.116553
inst✝³ : CoheytingAlgebra α
inst✝² : CoheytingAlgebra β
inst✝¹ : CoheytingAlgebra γ
inst✝ : CoheytingAlgebra δ
f f₁ f₂ : CoheytingHom α β
g g₁ g₂ : CoheytingHom β γ
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: Equiv.Perm.IsCycle.orderOf
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [orderOf_eq_card_zpowers, ← Fintype.card_coe]
state_before: ι : Type ?u.609092
α : Type u_1
β : Type ?u.609098
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : IsCycle f
⊢ orderOf f = card (support f)

tactic: convert Fintype.card_congr (IsCycle.zpowersEquivSupport hf)
state_before: ι : Type ?u.609092
α : Type u_1
β : Type ?u.609098
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : IsCycle f
⊢ Fintype.card { x // x ∈ Subgroup.zpowers f } = Fintype.card { x // x ∈ support f }
Theorem: Polynomial.taylor_coeff_zero
File: Mathlib/Data/Polynomial/Taylor.lean

tactic: rw [taylor_coeff, hasseDeriv_zero, LinearMap.id_apply]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
⊢ coeff (↑(taylor r) f) 0 = eval r f
Theorem: Real.one_sub_div_pow_le_exp_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: n : ℕ
t : ℝ
ht' : t ≤ ↑n
⊢ (1 - t / ↑n) ^ n ≤ exp (-t)

tactic: convert pow_le_pow_of_le_left ?_ (add_one_le_exp (-(t / n))) n using 2
state_before: case inr
n : ℕ
t : ℝ
ht' : t ≤ ↑n
hn : n ≠ 0
⊢ (1 - t / ↑n) ^ n ≤ exp (-t)

tactic: simp
state_before: case inl
t : ℝ
ht' : t ≤ ↑0
⊢ (1 - t / ↑0) ^ 0 ≤ exp (-t)

tactic: rwa [Nat.cast_zero] at ht'
state_before: case inl
t : ℝ
ht' : t ≤ ↑0
⊢ t ≤ 0

tactic: abel
state_before: case h.e'_3.h.e'_5
n : ℕ
t : ℝ
ht' : t ≤ ↑n
hn : n ≠ 0
⊢ 1 - t / ↑n = -(t / ↑n) + 1

tactic: rw [← Real.exp_nat_mul]
state_before: case h.e'_4
n : ℕ
t : ℝ
ht' : t ≤ ↑n
hn : n ≠ 0
⊢ exp (-t) = exp (-(t / ↑n)) ^ n

tactic: congr 1
state_before: case h.e'_4
n : ℕ
t : ℝ
ht' : t ≤ ↑n
hn : n ≠ 0
⊢ exp (-t) = exp (↑n * -(t / ↑n))

tactic: field_simp [(Nat.cast_ne_zero (R := ℝ)).mpr hn]
state_before: case h.e'_4.e_x
n : ℕ
t : ℝ
ht' : t ≤ ↑n
hn : n ≠ 0
⊢ -t = ↑n * -(t / ↑n)

tactic: ring_nf
state_before: case h.e'_4.e_x
n : ℕ
t : ℝ
ht' : t ≤ ↑n
hn : n ≠ 0
⊢ t * ↑n = ↑n * t

tactic: rwa [add_comm, ← sub_eq_add_neg, sub_nonneg, div_le_one]
state_before: case inr
n : ℕ
t : ℝ
ht' : t ≤ ↑n
hn : n ≠ 0
⊢ 0 ≤ -(t / ↑n) + 1

tactic: positivity
state_before: case inr
n : ℕ
t : ℝ
ht' : t ≤ ↑n
hn : n ≠ 0
⊢ 0 < ↑n
Theorem: ENNReal.iSup_mul
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [mul_comm, mul_iSup]
state_before: α : Type ?u.156200
β : Type ?u.156203
γ : Type ?u.156206
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ iSup f * a = ⨆ (i : ι), f i * a

tactic: congr
state_before: α : Type ?u.156200
β : Type ?u.156203
γ : Type ?u.156206
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ (⨆ (i : ι), a * f i) = ⨆ (i : ι), f i * a

tactic: funext
state_before: case e_s
α : Type ?u.156200
β : Type ?u.156203
γ : Type ?u.156206
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ (fun i => a * f i) = fun i => f i * a

tactic: rw [mul_comm]
state_before: case e_s.h
α : Type ?u.156200
β : Type ?u.156203
γ : Type ?u.156206
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f : ι → ℝ≥0∞
a : ℝ≥0∞
x✝ : ι
⊢ a * f x✝ = f x✝ * a
Theorem: Equiv.Perm.Disjoint.mono
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: rw [disjoint_iff_disjoint_support] at h⊢
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g x y : Perm α
h : Disjoint f g
hf : support x ≤ support f
hg : support y ≤ support g
⊢ Disjoint x y

tactic: exact h.mono hf hg
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g x y : Perm α
h✝ : Disjoint f g
h : _root_.Disjoint (support f) (support g)
hf : support x ≤ support f
hg : support y ≤ support g
⊢ _root_.Disjoint (support x) (support y)