tasksource/leandojo huggingface dataset:
Theorem: not_isOfFinOrder_of_injective_pow
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: simp_rw [isOfFinOrder_iff_pow_eq_one, not_exists, not_and]
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
x : G
h : Injective fun n => x ^ n
⊢ ¬IsOfFinOrder x

tactic: intro n hn_pos hnx
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
x : G
h : Injective fun n => x ^ n
⊢ ∀ (x_1 : ℕ), 0 < x_1 → ¬x ^ x_1 = 1

tactic: rw [← pow_zero x] at hnx
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n✝ m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
x : G
h : Injective fun n => x ^ n
n : ℕ
hn_pos : 0 < n
hnx : x ^ n = 1
⊢ False

tactic: rw [h hnx] at hn_pos
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n✝ m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
x : G
h : Injective fun n => x ^ n
n : ℕ
hn_pos : 0 < n
hnx : x ^ n = x ^ 0
⊢ False

tactic: exact irrefl 0 hn_pos
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n✝ m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
x : G
h : Injective fun n => x ^ n
n : ℕ
hn_pos : 0 < 0
hnx : x ^ n = x ^ 0
⊢ False
Theorem: imageToKernel_zero_right
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: ext
state_before: ι : Type ?u.9377
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝ : HasImages V
w : f ≫ 0 = 0
⊢ imageToKernel f 0 w = Subobject.arrow (imageSubobject f) ≫ inv (Subobject.arrow (kernelSubobject 0))

tactic: simp
state_before: case h
ι : Type ?u.9377
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝ : HasImages V
w : f ≫ 0 = 0
⊢ imageToKernel f 0 w ≫ Subobject.arrow (kernelSubobject 0) =
    (Subobject.arrow (imageSubobject f) ≫ inv (Subobject.arrow (kernelSubobject 0))) ≫
      Subobject.arrow (kernelSubobject 0)
Theorem: CategoryTheory.Groupoid.Free.lift_spec
File: Mathlib/CategoryTheory/Groupoid/FreeGroupoid.lean

tactic: rw [of_eq, Prefunctor.comp_assoc, Prefunctor.comp_assoc, Functor.toPrefunctor_comp]
state_before: V : Type u
inst✝¹ : Quiver V
V' : Type u'
inst✝ : Groupoid V'
φ✝ φ : V ⥤q V'
⊢ of V ⋙q (lift φ).toPrefunctor = φ

tactic: dsimp [lift]
state_before: V : Type u
inst✝¹ : Quiver V
V' : Type u'
inst✝ : Groupoid V'
φ✝ φ : V ⥤q V'
⊢ Quiver.Symmetrify.of ⋙q (Paths.of ⋙q (Quotient.functor redStep ⋙ lift φ).toPrefunctor) = φ

tactic: rw [Quotient.lift_spec, Paths.lift_spec, Quiver.Symmetrify.lift_spec]
state_before: V : Type u
inst✝¹ : Quiver V
V' : Type u'
inst✝ : Groupoid V'
φ✝ φ : V ⥤q V'
⊢ Quiver.Symmetrify.of ⋙q
      (Paths.of ⋙q
        (Quotient.functor redStep ⋙
            Quotient.lift redStep (Paths.lift (Quiver.Symmetrify.lift φ))
              (_ :
                ∀ (x y : Paths (Quiver.Symmetrify V)) (f₁ f₂ : x ⟶ y),
                  redStep f₁ f₂ →
                    (Paths.lift (Quiver.Symmetrify.lift φ)).map f₁ =
                      (Paths.lift (Quiver.Symmetrify.lift φ)).map f₂)).toPrefunctor) =
    φ
Theorem: CategoryTheory.MonoidalClosed.pre_id
File: Mathlib/CategoryTheory/Closed/Monoidal.lean

tactic: simp only [pre, Functor.map_id]
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : MonoidalCategory C
A✝ B X X' Y Y' Z : C
inst✝² : Closed A✝
inst✝¹ : Closed B
A : C
inst✝ : Closed A
⊢ pre (𝟙 A) = 𝟙 (ihom A)

tactic: dsimp
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : MonoidalCategory C
A✝ B X X' Y Y' Z : C
inst✝² : Closed A✝
inst✝¹ : Closed B
A : C
inst✝ : Closed A
⊢ ↑(transferNatTransSelf (ihom.adjunction A) (ihom.adjunction A)) (𝟙 ((tensoringLeft C).obj A)) = 𝟙 (ihom A)

tactic: simp
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : MonoidalCategory C
A✝ B X X' Y Y' Z : C
inst✝² : Closed A✝
inst✝¹ : Closed B
A : C
inst✝ : Closed A
⊢ ↑(transferNatTransSelf (ihom.adjunction A) (ihom.adjunction A)) (𝟙 (tensorLeft A)) = 𝟙 (ihom A)
Theorem: Complex.inv_I
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [inv_eq_one_div, div_I, one_mul]
state_before: ⊢ I⁻¹ = -I
Theorem: Ordnode.Raised.dist_le'
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [Nat.dist_comm]
state_before: α : Type ?u.244405
n m : ℕ
H : Raised n m
⊢ Nat.dist m n ≤ 1

tactic: exact H.dist_le
state_before: α : Type ?u.244405
n m : ℕ
H : Raised n m
⊢ Nat.dist n m ≤ 1
Theorem: SimpleGraph.Walk.subset_support_append_right
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: intro h
state_before: V✝ : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V✝
G' : SimpleGraph V'
G'' : SimpleGraph V''
V : Type u
G : SimpleGraph V
u v w : V
p : Walk G u v
q : Walk G v w
⊢ support q ⊆ support (append p q)

tactic: simp (config := { contextual := true }) only [mem_support_append_iff, or_true_iff, imp_true_iff]
state_before: V✝ : Type u
V' : Type v
V'' : Type w
G✝ : SimpleGraph V✝
G' : SimpleGraph V'
G'' : SimpleGraph V''
V : Type u
G : SimpleGraph V
u v w : V
p : Walk G u v
q : Walk G v w
h : V
⊢ h ∈ support q → h ∈ support (append p q)
Theorem: Nat.findGreatest_eq
File: Mathlib/Data/Nat/Basic.lean

tactic: simp [Nat.findGreatest, h]
state_before: m n✝ k : ℕ
P Q : ℕ → Prop
inst✝ : DecidablePred P
b n : ℕ
h : P (n + 1)
⊢ Nat.findGreatest P (n + 1) = n + 1
Theorem: Multiset.noncommFold_eq_fold
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: induction s using Quotient.inductionOn
state_before: F : Type ?u.4663
ι : Type ?u.4666
α : Type u_1
β : Type ?u.4672
γ : Type ?u.4675
f : α → β → β
op : α → α → α
assoc : IsAssociative α op
s : Multiset α
inst✝ : IsCommutative α op
a : α
⊢ noncommFold op s (_ : ∀ (x : α), x ∈ {x | x ∈ s} → ∀ (y : α), y ∈ {x | x ∈ s} → x ≠ y → op x y = op y x) a =
    fold op a s

tactic: simp
state_before: case h
F : Type ?u.4663
ι : Type ?u.4666
α : Type u_1
β : Type ?u.4672
γ : Type ?u.4675
f : α → β → β
op : α → α → α
assoc : IsAssociative α op
inst✝ : IsCommutative α op
a : α
a✝ : List α
⊢ noncommFold op (Quotient.mk (List.isSetoid α) a✝)
      (_ :
        ∀ (x : α),
          x ∈ {x | x ∈ Quotient.mk (List.isSetoid α) a✝} →
            ∀ (y : α), y ∈ {x | x ∈ Quotient.mk (List.isSetoid α) a✝} → x ≠ y → op x y = op y x)
      a =
    fold op a (Quotient.mk (List.isSetoid α) a✝)
Theorem: sdiff_le_comm
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sdiff_le_iff, sdiff_le_iff']
state_before: ι : Type ?u.88914
α : Type u_1
β : Type ?u.88920
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a \ b ≤ c ↔ a \ c ≤ b
Theorem: EqualCharZero.nonempty_algebraRat_iff
File: Mathlib/Algebra/CharP/MixedCharZero.lean

tactic: constructor
state_before: R : Type u_1
inst✝ : CommRing R
⊢ Nonempty (Algebra ℚ R) ↔ ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)

tactic: intro h_alg
state_before: case mp
R : Type u_1
inst✝ : CommRing R
⊢ Nonempty (Algebra ℚ R) → ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)

tactic: haveI h_alg' : Algebra ℚ R := h_alg.some
state_before: case mp
R : Type u_1
inst✝ : CommRing R
h_alg : Nonempty (Algebra ℚ R)
⊢ ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)

tactic: apply of_algebraRat
state_before: case mp
R : Type u_1
inst✝ : CommRing R
h_alg : Nonempty (Algebra ℚ R)
h_alg' : Algebra ℚ R
⊢ ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)

tactic: intro h
state_before: case mpr
R : Type u_1
inst✝ : CommRing R
⊢ (∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)) → Nonempty (Algebra ℚ R)

tactic: apply Nonempty.intro
state_before: case mpr
R : Type u_1
inst✝ : CommRing R
h : ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
⊢ Nonempty (Algebra ℚ R)

tactic: exact algebraRat h
state_before: case mpr.val
R : Type u_1
inst✝ : CommRing R
h : ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)
⊢ Algebra ℚ R
Theorem: MvPolynomial.totalDegree_pow
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: induction' n with n ih
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.456883
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q a : MvPolynomial σ R
n : ℕ
⊢ totalDegree (a ^ n) ≤ n * totalDegree a

tactic: rw [pow_succ]
state_before: case succ
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.456883
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q a : MvPolynomial σ R
n : ℕ
ih : totalDegree (a ^ n) ≤ n * totalDegree a
⊢ totalDegree (a ^ Nat.succ n) ≤ Nat.succ n * totalDegree a

tactic: calc
  totalDegree (a * a ^ n) ≤ a.totalDegree + (a ^ n).totalDegree := totalDegree_mul _ _
  _ ≤ a.totalDegree + n * a.totalDegree := (add_le_add_left ih _)
  _ = (n + 1) * a.totalDegree := by rw [add_mul, one_mul, add_comm]
state_before: case succ
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.456883
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q a : MvPolynomial σ R
n : ℕ
ih : totalDegree (a ^ n) ≤ n * totalDegree a
⊢ totalDegree (a * a ^ n) ≤ Nat.succ n * totalDegree a

tactic: simp only [Nat.zero_eq, MulZeroClass.zero_mul, pow_zero, totalDegree_one]
state_before: case zero
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.456883
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q a : MvPolynomial σ R
⊢ totalDegree (a ^ Nat.zero) ≤ Nat.zero * totalDegree a

tactic: rw [add_mul, one_mul, add_comm]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.456883
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q a : MvPolynomial σ R
n : ℕ
ih : totalDegree (a ^ n) ≤ n * totalDegree a
⊢ totalDegree a + n * totalDegree a = (n + 1) * totalDegree a
Theorem: Decidable.List.Lex.ne_iff
File: Mathlib/Data/List/Lex.lean

tactic: induction' l₁ with a l₁ IH generalizing l₂ <;> cases' l₂ with b l₂
state_before: α : Type u
inst✝ : DecidableEq α
l₁ l₂ : List α
H : length l₁ ≤ length l₂
h : l₁ ≠ l₂
⊢ Lex (fun x x_1 => x ≠ x_1) l₁ l₂

tactic: contradiction
state_before: case nil.nil
α : Type u
inst✝ : DecidableEq α
l₁ l₂ : List α
H✝ : length l₁ ≤ length l₂
h✝ : l₁ ≠ l₂
H : length [] ≤ length []
h : [] ≠ []
⊢ Lex (fun x x_1 => x ≠ x_1) [] []

tactic: apply nil
state_before: case nil.cons
α : Type u
inst✝ : DecidableEq α
l₁ l₂✝ : List α
H✝ : length l₁ ≤ length l₂✝
h✝ : l₁ ≠ l₂✝
b : α
l₂ : List α
H : length [] ≤ length (b :: l₂)
h : [] ≠ b :: l₂
⊢ Lex (fun x x_1 => x ≠ x_1) [] (b :: l₂)

tactic: exact (not_lt_of_ge H).elim (succ_pos _)
state_before: case cons.nil
α : Type u
inst✝ : DecidableEq α
l₁✝ l₂ : List α
H✝ : length l₁✝ ≤ length l₂
h✝ : l₁✝ ≠ l₂
a : α
l₁ : List α
IH : ∀ {l₂ : List α}, length l₁ ≤ length l₂ → l₁ ≠ l₂ → Lex (fun x x_1 => x ≠ x_1) l₁ l₂
H : length (a :: l₁) ≤ length []
h : a :: l₁ ≠ []
⊢ Lex (fun x x_1 => x ≠ x_1) (a :: l₁) []

tactic: by_cases ab : a = b
state_before: case cons.cons
α : Type u
inst✝ : DecidableEq α
l₁✝ l₂✝ : List α
H✝ : length l₁✝ ≤ length l₂✝
h✝ : l₁✝ ≠ l₂✝
a : α
l₁ : List α
IH : ∀ {l₂ : List α}, length l₁ ≤ length l₂ → l₁ ≠ l₂ → Lex (fun x x_1 => x ≠ x_1) l₁ l₂
b : α
l₂ : List α
H : length (a :: l₁) ≤ length (b :: l₂)
h : a :: l₁ ≠ b :: l₂
⊢ Lex (fun x x_1 => x ≠ x_1) (a :: l₁) (b :: l₂)

tactic: subst b
state_before: case pos
α : Type u
inst✝ : DecidableEq α
l₁✝ l₂✝ : List α
H✝ : length l₁✝ ≤ length l₂✝
h✝ : l₁✝ ≠ l₂✝
a : α
l₁ : List α
IH : ∀ {l₂ : List α}, length l₁ ≤ length l₂ → l₁ ≠ l₂ → Lex (fun x x_1 => x ≠ x_1) l₁ l₂
b : α
l₂ : List α
H : length (a :: l₁) ≤ length (b :: l₂)
h : a :: l₁ ≠ b :: l₂
ab : a = b
⊢ Lex (fun x x_1 => x ≠ x_1) (a :: l₁) (b :: l₂)

tactic: apply cons
state_before: case pos
α : Type u
inst✝ : DecidableEq α
l₁✝ l₂✝ : List α
H✝ : length l₁✝ ≤ length l₂✝
h✝ : l₁✝ ≠ l₂✝
a : α
l₁ : List α
IH : ∀ {l₂ : List α}, length l₁ ≤ length l₂ → l₁ ≠ l₂ → Lex (fun x x_1 => x ≠ x_1) l₁ l₂
l₂ : List α
H : length (a :: l₁) ≤ length (a :: l₂)
h : a :: l₁ ≠ a :: l₂
⊢ Lex (fun x x_1 => x ≠ x_1) (a :: l₁) (a :: l₂)

tactic: exact IH (le_of_succ_le_succ H) (mt (congr_arg _) h)
state_before: case pos.h
α : Type u
inst✝ : DecidableEq α
l₁✝ l₂✝ : List α
H✝ : length l₁✝ ≤ length l₂✝
h✝ : l₁✝ ≠ l₂✝
a : α
l₁ : List α
IH : ∀ {l₂ : List α}, length l₁ ≤ length l₂ → l₁ ≠ l₂ → Lex (fun x x_1 => x ≠ x_1) l₁ l₂
l₂ : List α
H : length (a :: l₁) ≤ length (a :: l₂)
h : a :: l₁ ≠ a :: l₂
⊢ Lex (fun x x_1 => x ≠ x_1) l₁ l₂

tactic: exact rel ab
state_before: case neg
α : Type u
inst✝ : DecidableEq α
l₁✝ l₂✝ : List α
H✝ : length l₁✝ ≤ length l₂✝
h✝ : l₁✝ ≠ l₂✝
a : α
l₁ : List α
IH : ∀ {l₂ : List α}, length l₁ ≤ length l₂ → l₁ ≠ l₂ → Lex (fun x x_1 => x ≠ x_1) l₁ l₂
b : α
l₂ : List α
H : length (a :: l₁) ≤ length (b :: l₂)
h : a :: l₁ ≠ b :: l₂
ab : ¬a = b
⊢ Lex (fun x x_1 => x ≠ x_1) (a :: l₁) (b :: l₂)
Theorem: ENNReal.exists_le_of_sum_le
File: Mathlib/Data/Real/ENNReal.lean

tactic: contrapose! Hle
state_before: α : Type u_1
β : Type ?u.206222
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Finset α
hs : Finset.Nonempty s
f g : α → ℝ≥0∞
Hle : ∑ i in s, f i ≤ ∑ i in s, g i
⊢ ∃ i, i ∈ s ∧ f i ≤ g i

tactic: apply ENNReal.sum_lt_sum_of_nonempty hs Hle
state_before: α : Type u_1
β : Type ?u.206222
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Finset α
hs : Finset.Nonempty s
f g : α → ℝ≥0∞
Hle : ∀ (i : α), i ∈ s → g i < f i
⊢ ∑ i in s, g i < ∑ i in s, f i
Theorem: AlternatingMap.map_update_self
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: rw [Function.update_same, Function.update_noteq hij.symm]
state_before: R : Type u_4
inst✝¹⁵ : Semiring R
M : Type u_3
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_2
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type ?u.411142
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type ?u.411172
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type ?u.411560
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_1
ι' : Type ?u.411951
ι'' : Type ?u.411954
M₂ : Type ?u.411957
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type ?u.411987
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
f f' : AlternatingMap R M N ι
g g₂ : AlternatingMap R M N' ι
g' : AlternatingMap R M' N' ι
v : ι → M
v' : ι → M'
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
⊢ update v i (v j) i = update v i (v j) j
Theorem: intervalIntegral.integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_right
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: simpa only [integral_const, smul_eq_mul, mul_one] using
  measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_right hab hmeas hf hu hv
state_before: ι : Type u_2
𝕜 : Type ?u.1636764
E : Type u_1
F : Type ?u.1636770
A : Type ?u.1636773
inst✝⁴ : NormedAddCommGroup E
inst✝³ : CompleteSpace E
inst✝² : NormedSpace ℝ E
f : ℝ → E
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
a b z : ℝ
u v ua ub va vb : ι → ℝ
inst✝¹ : FTCFilter a la la'
inst✝ : FTCFilter b lb lb'
hab : IntervalIntegrable f volume a b
hmeas : StronglyMeasurableAtFilter f lb'
hf : Tendsto f (lb' ⊓ Measure.ae volume) (𝓝 c)
hu : Tendsto u lt lb
hv : Tendsto v lt lb
⊢ (fun t => ((∫ (x : ℝ) in a..v t, f x) - ∫ (x : ℝ) in a..u t, f x) - (v t - u t) • c) =o[lt] (v - u)
Theorem: QuadraticForm.map_zero
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [← @zero_smul R _ _ _ _ (0 : M), map_smul, zero_mul, zero_mul]
state_before: S : Type ?u.126220
R : Type u_1
R₁ : Type ?u.126226
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
⊢ ↑Q 0 = 0
Theorem: pow_eq_zero_iff
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: refine' ⟨pow_eq_zero, _⟩
state_before: R : Type ?u.22317
S : Type ?u.22320
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : NoZeroDivisors M
a : M
n : ℕ
hn : 0 < n
⊢ a ^ n = 0 ↔ a = 0

tactic: rintro rfl
state_before: R : Type ?u.22317
S : Type ?u.22320
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : NoZeroDivisors M
a : M
n : ℕ
hn : 0 < n
⊢ a = 0 → a ^ n = 0

tactic: exact zero_pow hn
state_before: R : Type ?u.22317
S : Type ?u.22320
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : NoZeroDivisors M
n : ℕ
hn : 0 < n
⊢ 0 ^ n = 0
Theorem: RatFunc.liftMonoidWithZeroHom_apply
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [← num_div_denom f, liftMonoidWithZeroHom_apply_div, num_div_denom]
state_before: K : Type u
inst✝¹ : Field K
L : Type u_1
inst✝ : CommGroupWithZero L
φ : K[X] →*₀ L
hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰
f : RatFunc K
⊢ ↑(liftMonoidWithZeroHom φ hφ) f = ↑φ (num f) / ↑φ (denom f)
Theorem: Dfinsupp.erase_add_single
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: subst h
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f : Π₀ (i : ι), β i
i' : ι
h : i = i'
⊢ ↑(erase i f + single i (↑f i)) i' = ↑f i'

tactic: simp only [add_apply, single_apply, erase_apply, zero_add, dite_eq_ite, if_true]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f : Π₀ (i : ι), β i
⊢ ↑(erase i f + single i (↑f i)) i = ↑f i

tactic: simp only [add_apply, single_apply, erase_apply, dif_neg h, if_neg (Ne.symm h), add_zero]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
f : Π₀ (i : ι), β i
i' : ι
h : ¬i = i'
⊢ ↑(erase i f + single i (↑f i)) i' = ↑f i'
Theorem: finprod_mem_union_inter'
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← finprod_mem_inter_mulSupport f s, ← finprod_mem_inter_mulSupport f t, ←
  finprod_mem_union_inter hs ht, ← union_inter_distrib_right, finprod_mem_inter_mulSupport, ←
  finprod_mem_inter_mulSupport f (s ∩ t)]
state_before: α : Type u_1
β : Type ?u.330069
ι : Type ?u.330072
G : Type ?u.330075
M : Type u_2
N : Type ?u.330081
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : Set.Finite (s ∩ mulSupport f)
ht : Set.Finite (t ∩ mulSupport f)
⊢ ((∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ t), f i) =
    (∏ᶠ (i : α) (_ : i ∈ s), f i) * ∏ᶠ (i : α) (_ : i ∈ t), f i

tactic: congr 2
state_before: α : Type u_1
β : Type ?u.330069
ι : Type ?u.330072
G : Type ?u.330075
M : Type u_2
N : Type ?u.330081
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : Set.Finite (s ∩ mulSupport f)
ht : Set.Finite (t ∩ mulSupport f)
⊢ ((∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ t ∩ mulSupport f), f i) =
    (∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ mulSupport f ∩ (t ∩ mulSupport f)), f i

tactic: rw [inter_left_comm, inter_assoc, inter_assoc, inter_self, inter_left_comm]
state_before: case e_a.e_f
α : Type u_1
β : Type ?u.330069
ι : Type ?u.330072
G : Type ?u.330075
M : Type u_2
N : Type ?u.330081
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : Set.Finite (s ∩ mulSupport f)
ht : Set.Finite (t ∩ mulSupport f)
⊢ (fun i => ∏ᶠ (_ : i ∈ s ∩ t ∩ mulSupport f), f i) = fun i => ∏ᶠ (_ : i ∈ s ∩ mulSupport f ∩ (t ∩ mulSupport f)), f i
Theorem: Equiv.Perm.mem_cycleFactorsFinset_support_le
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [mem_cycleFactorsFinset_iff] at h
state_before: ι : Type ?u.2746614
α : Type u_1
β : Type ?u.2746620
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ p f : Perm α
h : p ∈ cycleFactorsFinset f
⊢ support p ≤ support f

tactic: intro x hx
state_before: ι : Type ?u.2746614
α : Type u_1
β : Type ?u.2746620
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ p f : Perm α
h : IsCycle p ∧ ∀ (a : α), a ∈ support p → ↑p a = ↑f a
⊢ support p ≤ support f

tactic: rwa [mem_support, ← h.right x hx, ← mem_support]
state_before: ι : Type ?u.2746614
α : Type u_1
β : Type ?u.2746620
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ p f : Perm α
h : IsCycle p ∧ ∀ (a : α), a ∈ support p → ↑p a = ↑f a
x : α
hx : x ∈ support p
⊢ x ∈ support f
Theorem: QuotientGroup.leftRel_r_eq_leftCosetEquivalence
File: Mathlib/GroupTheory/Coset.lean

tactic: ext
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
⊢ Setoid.r = LeftCosetEquivalence ↑s

tactic: rw [leftRel_eq]
state_before: case h.h.a
α : Type u_1
inst✝ : Group α
s : Subgroup α
x✝¹ x✝ : α
⊢ Setoid.r x✝¹ x✝ ↔ LeftCosetEquivalence (↑s) x✝¹ x✝

tactic: exact (leftCoset_eq_iff s).symm
state_before: case h.h.a
α : Type u_1
inst✝ : Group α
s : Subgroup α
x✝¹ x✝ : α
⊢ (fun x y => x⁻¹ * y ∈ s) x✝¹ x✝ ↔ LeftCosetEquivalence (↑s) x✝¹ x✝
Theorem: Finset.sum_card_slice
File: Mathlib/Data/Finset/Slice.lean

tactic: letI := Classical.decEq α
state_before: α : Type u_1
ι : Sort ?u.15793
κ : ι → Sort ?u.15798
𝒜 : Finset (Finset α)
A A₁ A₂ : Finset α
r r₁ r₂ : ℕ
inst✝ : Fintype α
⊢ ∑ r in Iic (Fintype.card α), card (𝒜 # r) = card 𝒜

tactic: rw [← card_biUnion, biUnion_slice]
state_before: α : Type u_1
ι : Sort ?u.15793
κ : ι → Sort ?u.15798
𝒜 : Finset (Finset α)
A A₁ A₂ : Finset α
r r₁ r₂ : ℕ
inst✝ : Fintype α
this : DecidableEq α := Classical.decEq α
⊢ ∑ r in Iic (Fintype.card α), card (𝒜 # r) = card 𝒜

tactic: exact Finset.pairwiseDisjoint_slice.subset (Set.subset_univ _)
state_before: α : Type u_1
ι : Sort ?u.15793
κ : ι → Sort ?u.15798
𝒜 : Finset (Finset α)
A A₁ A₂ : Finset α
r r₁ r₂ : ℕ
inst✝ : Fintype α
this : DecidableEq α := Classical.decEq α
⊢ ∀ (x : ℕ), x ∈ Iic (Fintype.card α) → ∀ (y : ℕ), y ∈ Iic (Fintype.card α) → x ≠ y → Disjoint (𝒜 # x) (𝒜 # y)
Theorem: Qpf.supp_eq
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: ext
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
x : F α
⊢ supp x = {u | ∀ (a : (P F).A) (f : PFunctor.B (P F) a → α), abs { fst := a, snd := f } = x → u ∈ f '' univ}

tactic: apply mem_supp
state_before: case h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
x : F α
x✝ : α
⊢ x✝ ∈ supp x ↔ x✝ ∈ {u | ∀ (a : (P F).A) (f : PFunctor.B (P F) a → α), abs { fst := a, snd := f } = x → u ∈ f '' univ}
Theorem: Set.image_update_Ioc_right
File: Mathlib/Data/Set/Intervals/Pi.lean

tactic: simpa using image_update_Ioc f i (f i) b
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
b : α i
⊢ update f i '' Ioc (f i) b = Ioc f (update f i b)
Theorem: Cardinal.mk_preimage_of_injective
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_id (#↑(f ⁻¹' s)), ← lift_id (#↑(s))]
state_before: α β : Type u
f : α → β
s : Set β
h : Injective f
⊢ (#↑(f ⁻¹' s)) ≤ (#↑s)

tactic: exact mk_preimage_of_injective_lift f s h
state_before: α β : Type u
f : α → β
s : Set β
h : Injective f
⊢ lift (#↑(f ⁻¹' s)) ≤ lift (#↑s)
Theorem: orderOf_eq_card_of_forall_mem_zpowers
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: classical
  rw [orderOf_eq_card_zpowers]
  apply Fintype.card_of_finset'
  simpa using hx
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
g : α
hx : ∀ (x : α), x ∈ zpowers g
⊢ orderOf g = Fintype.card α

tactic: rw [orderOf_eq_card_zpowers]
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
g : α
hx : ∀ (x : α), x ∈ zpowers g
⊢ orderOf g = Fintype.card α

tactic: apply Fintype.card_of_finset'
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
g : α
hx : ∀ (x : α), x ∈ zpowers g
⊢ Fintype.card { x // x ∈ zpowers g } = Fintype.card α

tactic: simpa using hx
state_before: case H
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Fintype α
g : α
hx : ∀ (x : α), x ∈ zpowers g
⊢ ∀ (x : α), x ∈ Finset.univ ↔ x ∈ ↑(zpowers g)