tasksource/leandojo huggingface dataset:
Theorem: Equiv.extendSubtype_apply_of_not_mem
File: Mathlib/Logic/Equiv/Fintype.lean

tactic: dsimp only [extendSubtype]
state_before: α : Type u_1
β : Type ?u.158045
inst✝³ : Fintype α
inst✝² : DecidableEq β
e✝ : Perm α
f : α ↪ β
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : ¬p x
⊢ ↑(extendSubtype e) x = ↑(↑(toCompl e) { val := x, property := hx })

tactic: simp only [subtypeCongr, Equiv.trans_apply, Equiv.sumCongr_apply]
state_before: α : Type u_1
β : Type ?u.158045
inst✝³ : Fintype α
inst✝² : DecidableEq β
e✝ : Perm α
f : α ↪ β
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : ¬p x
⊢ ↑(subtypeCongr e (toCompl e)) x = ↑(↑(toCompl e) { val := x, property := hx })

tactic: rw [sumCompl_apply_symm_of_neg _ _ hx, Sum.map_inr, sumCompl_apply_inr]
state_before: α : Type u_1
β : Type ?u.158045
inst✝³ : Fintype α
inst✝² : DecidableEq β
e✝ : Perm α
f : α ↪ β
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : ¬p x
⊢ ↑(sumCompl fun x => q x) (Sum.map (↑e) (↑(toCompl e)) (↑(sumCompl fun x => p x).symm x)) =
    ↑(↑(toCompl e) { val := x, property := hx })
Theorem: Fin.pred_eq_iff_eq_succ
File: Mathlib/Data/Fin/Basic.lean

tactic: simp only [← h, Fin.succ_pred]
state_before: n✝ m n : ℕ
i : Fin (n + 1)
hi : i ≠ 0
j : Fin n
h : pred i hi = j
⊢ i = succ j

tactic: simp only [h, Fin.pred_succ]
state_before: n✝ m n : ℕ
i : Fin (n + 1)
hi : i ≠ 0
j : Fin n
h : i = succ j
⊢ pred i hi = j
Theorem: List.reverse_cons'
File: Mathlib/Data/List/Basic.lean

tactic: simp only [reverse_cons, concat_eq_append]
state_before: ι : Type ?u.26301
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
⊢ reverse (a :: l) = concat (reverse l) a
Theorem: SimpleGraph.Walk.IsCycle.rotate
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: refine ⟨hc.isCircuit.rotate _, ?_⟩
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v : V
c : Walk G v v
hc : IsCycle c
h : u ∈ support c
⊢ IsCycle (rotate c h)

tactic: rw [List.IsRotated.nodup_iff (support_rotate _ _)]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v : V
c : Walk G v v
hc : IsCycle c
h : u ∈ support c
⊢ List.Nodup (List.tail (support (rotate c h)))

tactic: exact hc.support_nodup
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v : V
c : Walk G v v
hc : IsCycle c
h : u ∈ support c
⊢ List.Nodup (List.tail (support c))
Theorem: Mathlib.Tactic.Ring.pow_congr
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a a' : R
b b' : ℕ
c : R
x✝² : a = a'
x✝¹ : b = b'
x✝ : a' ^ b' = c
⊢ a ^ b = c

tactic: rfl
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a' : R
b' : ℕ
⊢ a' ^ b' = a' ^ b'
Theorem: Ordinal.add_right_cancel
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp only [le_antisymm_iff, add_le_add_iff_right]
state_before: α : Type ?u.77971
β : Type ?u.77974
γ : Type ?u.77977
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
n : ℕ
⊢ a + ↑n = b + ↑n ↔ a = b
Theorem: finRotate_succ_eq_decomposeFin
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: ext i
state_before: n : ℕ
⊢ finRotate (Nat.succ n) = ↑decomposeFin.symm (1, finRotate n)

tactic: cases n
state_before: case H.h
n : ℕ
i : Fin (Nat.succ n)
⊢ ↑(↑(finRotate (Nat.succ n)) i) = ↑(↑(↑decomposeFin.symm (1, finRotate n)) i)

tactic: refine' Fin.cases _ (fun i => _) i
state_before: case H.h.succ
n✝ : ℕ
i : Fin (Nat.succ (Nat.succ n✝))
⊢ ↑(↑(finRotate (Nat.succ (Nat.succ n✝))) i) = ↑(↑(↑decomposeFin.symm (1, finRotate (Nat.succ n✝))) i)

tactic: rw [coe_finRotate, decomposeFin_symm_apply_succ, if_congr i.succ_eq_last_succ rfl rfl]
state_before: case H.h.succ.refine'_2
n✝ : ℕ
i✝ : Fin (Nat.succ (Nat.succ n✝))
i : Fin (n✝ + 1)
⊢ ↑(↑(finRotate (Nat.succ (Nat.succ n✝))) (Fin.succ i)) =
    ↑(↑(↑decomposeFin.symm (1, finRotate (Nat.succ n✝))) (Fin.succ i))

tactic: split_ifs with h
state_before: case H.h.succ.refine'_2
n✝ : ℕ
i✝ : Fin (Nat.succ (Nat.succ n✝))
i : Fin (n✝ + 1)
⊢ (if i = Fin.last n✝ then 0 else ↑(Fin.succ i) + 1) = ↑(↑(swap 0 1) (Fin.succ (↑(finRotate (Nat.succ n✝)) i)))

tactic: simp
state_before: case H.h.zero
i : Fin (Nat.succ Nat.zero)
⊢ ↑(↑(finRotate (Nat.succ Nat.zero)) i) = ↑(↑(↑decomposeFin.symm (1, finRotate Nat.zero)) i)

tactic: simp
state_before: case H.h.succ.refine'_1
n✝ : ℕ
i : Fin (Nat.succ (Nat.succ n✝))
⊢ ↑(↑(finRotate (Nat.succ (Nat.succ n✝))) 0) = ↑(↑(↑decomposeFin.symm (1, finRotate (Nat.succ n✝))) 0)

tactic: simp [h]
state_before: case H.h.succ.refine'_2.inl
n✝ : ℕ
i✝ : Fin (Nat.succ (Nat.succ n✝))
i : Fin (n✝ + 1)
h : i = Fin.last n✝
⊢ 0 = ↑(↑(swap 0 1) (Fin.succ (↑(finRotate (Nat.succ n✝)) i)))

tactic: rw [Fin.val_succ, Function.Injective.map_swap Fin.val_injective, Fin.val_succ, coe_finRotate,
  if_neg h, Fin.val_zero, Fin.val_one,
  swap_apply_of_ne_of_ne (Nat.succ_ne_zero _) (Nat.succ_succ_ne_one _)]
state_before: case H.h.succ.refine'_2.inr
n✝ : ℕ
i✝ : Fin (Nat.succ (Nat.succ n✝))
i : Fin (n✝ + 1)
h : ¬i = Fin.last n✝
⊢ ↑(Fin.succ i) + 1 = ↑(↑(swap 0 1) (Fin.succ (↑(finRotate (Nat.succ n✝)) i)))
Theorem: Matrix.IsDiag.smul
File: Mathlib/LinearAlgebra/Matrix/IsDiag.lean

tactic: intro i j h
state_before: α : Type u_2
β : Type ?u.8104
R : Type u_1
n : Type u_3
m : Type ?u.8113
inst✝² : Monoid R
inst✝¹ : AddMonoid α
inst✝ : DistribMulAction R α
k : R
A : Matrix n n α
ha : IsDiag A
⊢ IsDiag (k • A)

tactic: simp [ha h]
state_before: α : Type u_2
β : Type ?u.8104
R : Type u_1
n : Type u_3
m : Type ?u.8113
inst✝² : Monoid R
inst✝¹ : AddMonoid α
inst✝ : DistribMulAction R α
k : R
A : Matrix n n α
ha : IsDiag A
i j : n
h : i ≠ j
⊢ (k • A) i j = 0
Theorem: AffineIsometry.linear_eq_linearIsometry
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: ext
state_before: 𝕜 : Type u_3
V : Type u_1
V₁ : Type ?u.16180
V₂ : Type u_2
V₃ : Type ?u.16186
V₄ : Type ?u.16189
P₁ : Type ?u.16192
P : Type u_4
P₂ : Type u_5
P₃ : Type ?u.16201
P₄ : Type ?u.16204
inst✝²⁰ : NormedField 𝕜
inst✝¹⁹ : SeminormedAddCommGroup V
inst✝¹⁸ : SeminormedAddCommGroup V₁
inst✝¹⁷ : SeminormedAddCommGroup V₂
inst✝¹⁶ : SeminormedAddCommGroup V₃
inst✝¹⁵ : SeminormedAddCommGroup V₄
inst✝¹⁴ : NormedSpace 𝕜 V
inst✝¹³ : NormedSpace 𝕜 V₁
inst✝¹² : NormedSpace 𝕜 V₂
inst✝¹¹ : NormedSpace 𝕜 V₃
inst✝¹⁰ : NormedSpace 𝕜 V₄
inst✝⁹ : PseudoMetricSpace P
inst✝⁸ : MetricSpace P₁
inst✝⁷ : PseudoMetricSpace P₂
inst✝⁶ : PseudoMetricSpace P₃
inst✝⁵ : PseudoMetricSpace P₄
inst✝⁴ : NormedAddTorsor V P
inst✝³ : NormedAddTorsor V₁ P₁
inst✝² : NormedAddTorsor V₂ P₂
inst✝¹ : NormedAddTorsor V₃ P₃
inst✝ : NormedAddTorsor V₄ P₄
f : P →ᵃⁱ[𝕜] P₂
⊢ f.linear = (AffineIsometry.linearIsometry f).toLinearMap

tactic: rfl
state_before: case h
𝕜 : Type u_3
V : Type u_1
V₁ : Type ?u.16180
V₂ : Type u_2
V₃ : Type ?u.16186
V₄ : Type ?u.16189
P₁ : Type ?u.16192
P : Type u_4
P₂ : Type u_5
P₃ : Type ?u.16201
P₄ : Type ?u.16204
inst✝²⁰ : NormedField 𝕜
inst✝¹⁹ : SeminormedAddCommGroup V
inst✝¹⁸ : SeminormedAddCommGroup V₁
inst✝¹⁷ : SeminormedAddCommGroup V₂
inst✝¹⁶ : SeminormedAddCommGroup V₃
inst✝¹⁵ : SeminormedAddCommGroup V₄
inst✝¹⁴ : NormedSpace 𝕜 V
inst✝¹³ : NormedSpace 𝕜 V₁
inst✝¹² : NormedSpace 𝕜 V₂
inst✝¹¹ : NormedSpace 𝕜 V₃
inst✝¹⁰ : NormedSpace 𝕜 V₄
inst✝⁹ : PseudoMetricSpace P
inst✝⁸ : MetricSpace P₁
inst✝⁷ : PseudoMetricSpace P₂
inst✝⁶ : PseudoMetricSpace P₃
inst✝⁵ : PseudoMetricSpace P₄
inst✝⁴ : NormedAddTorsor V P
inst✝³ : NormedAddTorsor V₁ P₁
inst✝² : NormedAddTorsor V₂ P₂
inst✝¹ : NormedAddTorsor V₃ P₃
inst✝ : NormedAddTorsor V₄ P₄
f : P →ᵃⁱ[𝕜] P₂
x✝ : V
⊢ ↑f.linear x✝ = ↑(AffineIsometry.linearIsometry f).toLinearMap x✝
Theorem: Nat.Linear.Expr.denote_toPoly
File: src/lean/Init/Data/Nat/Linear.lean

tactic: induction e with
| num k => by_cases h : k == 0 <;> simp [toPoly, h, Var.denote]; simp [eq_of_beq h]
| var i => simp [toPoly]
| add a b iha ihb => simp [toPoly, iha, ihb]
| mulL k a ih => simp [toPoly, ih, -Poly.mul]
| mulR k a ih => simp [toPoly, ih, -Poly.mul]
state_before: ctx : Context
e : Expr
⊢ Poly.denote ctx (toPoly e) = denote ctx e

tactic: by_cases h : k == 0 <;> simp [toPoly, h, Var.denote]
state_before: case num
ctx : Context
k : Nat
⊢ Poly.denote ctx (toPoly (num k)) = denote ctx (num k)

tactic: simp [eq_of_beq h]
state_before: case num.inl
ctx : Context
k : Nat
h : (k == 0) = true
⊢ 0 = k

tactic: simp [toPoly]
state_before: case var
ctx : Context
i : Var
⊢ Poly.denote ctx (toPoly (var i)) = denote ctx (var i)

tactic: simp [toPoly, iha, ihb]
state_before: case add
ctx : Context
a b : Expr
iha : Poly.denote ctx (toPoly a) = denote ctx a
ihb : Poly.denote ctx (toPoly b) = denote ctx b
⊢ Poly.denote ctx (toPoly (add a b)) = denote ctx (add a b)

tactic: simp [toPoly, ih, -Poly.mul]
state_before: case mulL
ctx : Context
k : Nat
a : Expr
ih : Poly.denote ctx (toPoly a) = denote ctx a
⊢ Poly.denote ctx (toPoly (mulL k a)) = denote ctx (mulL k a)

tactic: simp [toPoly, ih, -Poly.mul]
state_before: case mulR
ctx : Context
k : Expr
a : Nat
ih : Poly.denote ctx (toPoly k) = denote ctx k
⊢ Poly.denote ctx (toPoly (mulR k a)) = denote ctx (mulR k a)
Theorem: QuotientAddGroup.zmultiples_zsmul_eq_zsmul_iff
File: Mathlib/Algebra/CharZero/Quotient.lean

tactic: induction ψ using Quotient.inductionOn'
state_before: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p : R
ψ θ : R ⧸ AddSubgroup.zmultiples p
z : ℤ
hz : z ≠ 0
⊢ z • ψ = z • θ ↔ ∃ k, ψ = θ + ↑(↑k • (p / ↑z))

tactic: induction θ using Quotient.inductionOn'
state_before: case h
R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p : R
θ : R ⧸ AddSubgroup.zmultiples p
z : ℤ
hz : z ≠ 0
a✝ : R
⊢ z • Quotient.mk'' a✝ = z • θ ↔ ∃ k, Quotient.mk'' a✝ = θ + ↑(↑k • (p / ↑z))

tactic: let Zp := AddSubgroup.zmultiples p
state_before: case h.h
R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p : R
z : ℤ
hz : z ≠ 0
a✝¹ a✝ : R
⊢ z • Quotient.mk'' a✝¹ = z • Quotient.mk'' a✝ ↔ ∃ k, Quotient.mk'' a✝¹ = Quotient.mk'' a✝ + ↑(↑k • (p / ↑z))

tactic: have : (Quotient.mk'' : R → R ⧸ Zp) = ((↑) : R → R ⧸ Zp) := rfl
state_before: case h.h
R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p : R
z : ℤ
hz : z ≠ 0
a✝¹ a✝ : R
Zp : AddSubgroup R := AddSubgroup.zmultiples p
⊢ z • Quotient.mk'' a✝¹ = z • Quotient.mk'' a✝ ↔ ∃ k, Quotient.mk'' a✝¹ = Quotient.mk'' a✝ + ↑(↑k • (p / ↑z))

tactic: simp only [this]
state_before: case h.h
R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p : R
z : ℤ
hz : z ≠ 0
a✝¹ a✝ : R
Zp : AddSubgroup R := AddSubgroup.zmultiples p
this : Quotient.mk'' = mk
⊢ z • Quotient.mk'' a✝¹ = z • Quotient.mk'' a✝ ↔ ∃ k, Quotient.mk'' a✝¹ = Quotient.mk'' a✝ + ↑(↑k • (p / ↑z))

tactic: simp_rw [← QuotientAddGroup.mk_zsmul, ← QuotientAddGroup.mk_add,
  QuotientAddGroup.eq_iff_sub_mem, ← smul_sub, ← sub_sub]
state_before: case h.h
R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p : R
z : ℤ
hz : z ≠ 0
a✝¹ a✝ : R
Zp : AddSubgroup R := AddSubgroup.zmultiples p
this : Quotient.mk'' = mk
⊢ z • ↑a✝¹ = z • ↑a✝ ↔ ∃ k, ↑a✝¹ = ↑a✝ + ↑(↑k • (p / ↑z))

tactic: exact AddSubgroup.zsmul_mem_zmultiples_iff_exists_sub_div hz
state_before: case h.h
R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p : R
z : ℤ
hz : z ≠ 0
a✝¹ a✝ : R
Zp : AddSubgroup R := AddSubgroup.zmultiples p
this : Quotient.mk'' = mk
⊢ z • (a✝¹ - a✝) ∈ AddSubgroup.zmultiples p ↔ ∃ k, a✝¹ - a✝ - ↑k • (p / ↑z) ∈ AddSubgroup.zmultiples p
Theorem: Finset.piecewise_insert_self
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [piecewise]
state_before: α : Type u_1
β : Type ?u.294118
γ : Type ?u.294121
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
⊢ piecewise (insert j s) f g j = f j
Theorem: Finsupp.single_add_erase
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rw [← update_eq_single_add_erase, update_self]
state_before: α : Type u_1
β : Type ?u.305712
γ : Type ?u.305715
ι : Type ?u.305718
M : Type u_2
M' : Type ?u.305724
N : Type ?u.305727
P : Type ?u.305730
G : Type ?u.305733
H : Type ?u.305736
R : Type ?u.305739
S : Type ?u.305742
inst✝ : AddZeroClass M
a : α
f : α →₀ M
⊢ single a (↑f a) + erase a f = f
Theorem: List.Func.get_sub
File: Mathlib/Data/List/Func.lean

tactic: apply @get_pointwise _ _ _ ⟨0⟩ ⟨0⟩ ⟨0⟩
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u
inst✝ : AddGroup α
k : ℕ
xs ys : List α
⊢ get k (sub xs ys) = get k xs - get k ys

tactic: apply sub_zero
state_before: case h1
α✝ : Type u
β : Type v
γ : Type w
α : Type u
inst✝ : AddGroup α
k : ℕ
xs ys : List α
⊢ Sub.sub default default = default
Theorem: Matrix.IsAdjMatrix.apply_diag_ne
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: simp [h.apply_diag i]
state_before: V : Type u_2
α : Type u_1
β : Type ?u.360
A : Matrix V V α
inst✝¹ : MulZeroOneClass α
inst✝ : Nontrivial α
h : IsAdjMatrix A
i : V
⊢ ¬A i i = 1
Theorem: Finset.erase_biUnion
File: Mathlib/Data/Finset/Basic.lean

tactic: ext a
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.522272
inst✝ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ f : α → Finset β
s : Finset α
b : β
⊢ erase (Finset.biUnion s f) b = Finset.biUnion s fun x => erase (f x) b

tactic: simp [Finset.mem_biUnion, iff_self_iff, exists_and_left, Finset.mem_erase]
state_before: case a
α : Type u_2
β : Type u_1
γ : Type ?u.522272
inst✝ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ f : α → Finset β
s : Finset α
b a : β
⊢ a ∈ erase (Finset.biUnion s f) b ↔ a ∈ Finset.biUnion s fun x => erase (f x) b

tactic: tauto
state_before: case a
α : Type u_2
β : Type u_1
γ : Type ?u.522272
inst✝ : DecidableEq β
s✝ s₁ s₂ : Finset α
t t₁ t₂ f : α → Finset β
s : Finset α
b a : β
⊢ (¬a = b ∧ ∃ a_1, a_1 ∈ s ∧ a ∈ f a_1) ↔ ∃ a_1, a_1 ∈ s ∧ ¬a = b ∧ a ∈ f a_1
Theorem: Fin.succAbove_last
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n m : ℕ
⊢ succAbove (last n) = castSucc

tactic: simp only [succAbove_below, castSucc_lt_last]
state_before: case h.h
n m : ℕ
x✝ : Fin n
⊢ ↑(↑(succAbove (last n)) x✝) = ↑(↑castSucc x✝)
Theorem: Finset.prod_lt_prod'
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: classical
  rcases Hlt with ⟨i, hi, hlt⟩
  rw [← insert_erase hi, prod_insert (not_mem_erase _ _), prod_insert (not_mem_erase _ _)]
  exact mul_lt_mul_of_lt_of_le hlt (prod_le_prod' fun j hj ↦ Hle j <| mem_of_mem_erase hj)
state_before: ι : Type u_1
α : Type ?u.125163
β : Type ?u.125166
M : Type u_2
N : Type ?u.125172
G : Type ?u.125175
k : Type ?u.125178
R : Type ?u.125181
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
Hle : ∀ (i : ι), i ∈ s → f i ≤ g i
Hlt : ∃ i, i ∈ s ∧ f i < g i
⊢ ∏ i in s, f i < ∏ i in s, g i

tactic: rcases Hlt with ⟨i, hi, hlt⟩
state_before: ι : Type u_1
α : Type ?u.125163
β : Type ?u.125166
M : Type u_2
N : Type ?u.125172
G : Type ?u.125175
k : Type ?u.125178
R : Type ?u.125181
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
Hle : ∀ (i : ι), i ∈ s → f i ≤ g i
Hlt : ∃ i, i ∈ s ∧ f i < g i
⊢ ∏ i in s, f i < ∏ i in s, g i

tactic: rw [← insert_erase hi, prod_insert (not_mem_erase _ _), prod_insert (not_mem_erase _ _)]
state_before: case intro.intro
ι : Type u_1
α : Type ?u.125163
β : Type ?u.125166
M : Type u_2
N : Type ?u.125172
G : Type ?u.125175
k : Type ?u.125178
R : Type ?u.125181
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
Hle : ∀ (i : ι), i ∈ s → f i ≤ g i
i : ι
hi : i ∈ s
hlt : f i < g i
⊢ ∏ i in s, f i < ∏ i in s, g i

tactic: exact mul_lt_mul_of_lt_of_le hlt (prod_le_prod' fun j hj ↦ Hle j <| mem_of_mem_erase hj)
state_before: case intro.intro
ι : Type u_1
α : Type ?u.125163
β : Type ?u.125166
M : Type u_2
N : Type ?u.125172
G : Type ?u.125175
k : Type ?u.125178
R : Type ?u.125181
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
Hle : ∀ (i : ι), i ∈ s → f i ≤ g i
i : ι
hi : i ∈ s
hlt : f i < g i
⊢ f i * ∏ x in erase s i, f x < g i * ∏ x in erase s i, g x
Theorem: TopCat.sigmaIsoSigma_inv_apply
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

tactic: rw [← sigmaIsoSigma_hom_ι_apply, ← comp_app]
state_before: J : Type v
inst✝ : SmallCategory J
ι : Type v
α : ι → TopCatMax
i : ι
x : ↑(α i)
⊢ (forget TopCat).map (sigmaIsoSigma α).inv { fst := i, snd := x } = (forget TopCat).map (Sigma.ι α i) x

tactic: simp
state_before: J : Type v
inst✝ : SmallCategory J
ι : Type v
α : ι → TopCatMax
i : ι
x : ↑(α i)
⊢ (forget TopCat).map ((sigmaIsoSigma α).hom ≫ (sigmaIsoSigma α).inv) ((forget TopCat).map (Sigma.ι α i) x) =
    (forget TopCat).map (Sigma.ι α i) x
Theorem: Asymptotics.IsBigOWith.pow'
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa using isBigOWith_const_const (1 : R) (one_ne_zero' 𝕜) l
state_before: α : Type u_1
β : Type ?u.481261
E : Type ?u.481264
F : Type ?u.481267
G : Type ?u.481270
E' : Type ?u.481273
F' : Type ?u.481276
G' : Type ?u.481279
E'' : Type ?u.481282
F'' : Type ?u.481285
G'' : Type ?u.481288
R : Type u_2
R' : Type ?u.481294
𝕜 : Type u_3
𝕜' : Type ?u.481300
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g✝ : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f : α → R
g : α → 𝕜
h : IsBigOWith c l f g
⊢ IsBigOWith (Nat.casesOn 0 ‖1‖ fun n => c ^ (n + 1)) l (fun x => f x ^ 0) fun x => g x ^ 0

tactic: simpa
state_before: α : Type u_1
β : Type ?u.481261
E : Type ?u.481264
F : Type ?u.481267
G : Type ?u.481270
E' : Type ?u.481273
F' : Type ?u.481276
G' : Type ?u.481279
E'' : Type ?u.481282
F'' : Type ?u.481285
G'' : Type ?u.481288
R : Type u_2
R' : Type ?u.481294
𝕜 : Type u_3
𝕜' : Type ?u.481300
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g✝ : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f : α → R
g : α → 𝕜
h : IsBigOWith c l f g
⊢ IsBigOWith (Nat.casesOn 1 ‖1‖ fun n => c ^ (n + 1)) l (fun x => f x ^ 1) fun x => g x ^ 1

tactic: simpa [pow_succ] using h.mul (IsBigOWith.pow' h (n + 1))
state_before: α : Type u_1
β : Type ?u.481261
E : Type ?u.481264
F : Type ?u.481267
G : Type ?u.481270
E' : Type ?u.481273
F' : Type ?u.481276
G' : Type ?u.481279
E'' : Type ?u.481282
F'' : Type ?u.481285
G'' : Type ?u.481288
R : Type u_2
R' : Type ?u.481294
𝕜 : Type u_3
𝕜' : Type ?u.481300
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g✝ : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f : α → R
g : α → 𝕜
h : IsBigOWith c l f g
n : ℕ
⊢ IsBigOWith (Nat.casesOn (n + 2) ‖1‖ fun n => c ^ (n + 1)) l (fun x => f x ^ (n + 2)) fun x => g x ^ (n + 2)
Theorem: ModularGroup.T_pow_mul_apply_one
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

tactic: simp [coe_T_zpow, Matrix.mul, Matrix.dotProduct, Fin.sum_univ_succ]
state_before: n : ℤ
g : SL(2, ℤ)
⊢ ↑(T ^ n * g) 1 = ↑g 1
Theorem: Set.Finite.subset_toFinset
File: Mathlib/Data/Set/Finite.lean

tactic: rw [← Finset.coe_subset, Finite.coe_toFinset]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
a : α
hs : Set.Finite s✝
ht : Set.Finite t
s : Finset α
⊢ s ⊆ Finite.toFinset ht ↔ ↑s ⊆ t
Theorem: ENNReal.isOpen_Ico_zero
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [ENNReal.Ico_eq_Iio]
state_before: α : Type ?u.22170
β : Type ?u.22173
γ : Type ?u.22176
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ IsOpen (Ico 0 b)

tactic: exact isOpen_Iio
state_before: α : Type ?u.22170
β : Type ?u.22173
γ : Type ?u.22176
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ IsOpen (Iio b)
Theorem: MatrixEquivTensor.invFun_algebraMap
File: Mathlib/RingTheory/MatrixAlgebra.lean

tactic: dsimp [invFun]
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n R
⊢ invFun R A n (Matrix.map M ↑(algebraMap R A)) = 1 ⊗ₜ[R] M

tactic: simp only [Algebra.algebraMap_eq_smul_one, smul_tmul, ← tmul_sum, mul_boole]
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n R
⊢ ∑ p : n × n, ↑(algebraMap R A) (M p.fst p.snd) ⊗ₜ[R] stdBasisMatrix p.fst p.snd 1 = 1 ⊗ₜ[R] M

tactic: congr
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n R
⊢ 1 ⊗ₜ[R] ∑ a : n × n, M a.fst a.snd • stdBasisMatrix a.fst a.snd 1 = 1 ⊗ₜ[R] M

tactic: conv_rhs => rw [matrix_eq_sum_std_basis M]
state_before: case e_n
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n R
⊢ ∑ a : n × n, M a.fst a.snd • stdBasisMatrix a.fst a.snd 1 = M

tactic: convert Finset.sum_product (β := Matrix n n R)
state_before: case e_n
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n R
⊢ ∑ a : n × n, M a.fst a.snd • stdBasisMatrix a.fst a.snd 1 = ∑ i : n, ∑ j : n, stdBasisMatrix i j (M i j)

tactic: simp
state_before: case h.e'_3.a.a
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n R
x✝¹ : n
a✝¹ : x✝¹ ∈ Finset.univ
x✝ : n
a✝ : x✝ ∈ Finset.univ
⊢ stdBasisMatrix x✝¹ x✝ (M x✝¹ x✝) = M (x✝¹, x✝).fst (x✝¹, x✝).snd • stdBasisMatrix (x✝¹, x✝).fst (x✝¹, x✝).snd 1
Theorem: Nat.card_fintypeIcc
File: Mathlib/Data/Nat/Interval.lean

tactic: rw [Fintype.card_ofFinset, card_Icc]
state_before: a b c : ℕ
⊢ Fintype.card ↑(Set.Icc a b) = b + 1 - a
Theorem: circleIntegral.integral_smul_const
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp only [circleIntegral, intervalIntegral.integral_smul_const, ← smul_assoc]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → ℂ
a : E
c : ℂ
R : ℝ
⊢ (∮ (z : ℂ) in C(c, R), f z • a) = (∮ (z : ℂ) in C(c, R), f z) • a