tasksource/leandojo huggingface dataset:
Theorem: LinearMap.iterate_bijective
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [iterate_succ]
state_before: R : Type u_2
R₁ : Type ?u.202599
R₂ : Type ?u.202602
R₃ : Type ?u.202605
R₄ : Type ?u.202608
S : Type ?u.202611
K : Type ?u.202614
K₂ : Type ?u.202617
M : Type u_1
M' : Type ?u.202623
M₁ : Type ?u.202626
M₂ : Type ?u.202629
M₃ : Type ?u.202632
M₄ : Type ?u.202635
N : Type ?u.202638
N₂ : Type ?u.202641
ι : Type ?u.202644
V : Type ?u.202647
V₂ : Type ?u.202650
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : Semiring R₄
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid M₁
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R M
inst✝⁷ : Module R M₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : Module R₄ M₄
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₃₄ : R₃ →+* R₄
σ₁₃ : R →+* R₃
σ₂₄ : R₂ →+* R₄
σ₁₄ : R →+* R₄
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
f : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₃] M₃
f' : M →ₗ[R] M
h : Bijective ↑f'
n : ℕ
⊢ Bijective ↑(f' ^ (n + 1))

tactic: exact (iterate_bijective h n).comp h
state_before: R : Type u_2
R₁ : Type ?u.202599
R₂ : Type ?u.202602
R₃ : Type ?u.202605
R₄ : Type ?u.202608
S : Type ?u.202611
K : Type ?u.202614
K₂ : Type ?u.202617
M : Type u_1
M' : Type ?u.202623
M₁ : Type ?u.202626
M₂ : Type ?u.202629
M₃ : Type ?u.202632
M₄ : Type ?u.202635
N : Type ?u.202638
N₂ : Type ?u.202641
ι : Type ?u.202644
V : Type ?u.202647
V₂ : Type ?u.202650
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : Semiring R₄
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid M₁
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R M
inst✝⁷ : Module R M₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : Module R₄ M₄
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₃₄ : R₃ →+* R₄
σ₁₃ : R →+* R₃
σ₂₄ : R₂ →+* R₄
σ₁₄ : R →+* R₄
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
f : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₃] M₃
f' : M →ₗ[R] M
h : Bijective ↑f'
n : ℕ
⊢ Bijective ↑(comp (f' ^ n) f')
Theorem: Set.unop_mem_unop
File: Mathlib/Data/Set/Opposite.lean

tactic: rfl
state_before: α : Type u_1
s : Set αᵒᵖ
a : αᵒᵖ
⊢ a.unop ∈ Set.unop s ↔ a ∈ s
Theorem: Subgroup.disjoint_def
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp only [Disjoint, SetLike.le_def, mem_inf, mem_bot, and_imp]
state_before: G : Type u_1
G' : Type ?u.725393
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.725402
inst✝¹ : AddGroup A
N : Type ?u.725408
inst✝ : Group N
H₁ H₂ : Subgroup G
⊢ H₁ ⊓ H₂ ≤ ⊥ ↔ ∀ {x : G}, x ∈ H₁ → x ∈ H₂ → x = 1
Theorem: Pi.toLex_monotone
File: Mathlib/Data/Pi/Lex.lean

tactic: contrapose! hl
state_before: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : LinearOrder ι
inst✝¹ : IsWellOrder ι fun x x_1 => x < x_1
inst✝ : (i : ι) → PartialOrder (β i)
x y : (i : ι) → β i
i✝ : ι
a✝ : β i✝
a b : (i : ι) → β i
h : a ≤ b
hne : ¬↑toLex a = ↑toLex b
i : ι
hi : i ∈ {i | a i ≠ b i}
hl : ∀ (x : ι), x ∈ {i | a i ≠ b i} → ¬x < i
j : ι
hj : (fun x x_1 => x < x_1) j i
⊢ ↑toLex a j = ↑toLex b j

tactic: exact ⟨j, hl, hj⟩
state_before: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : LinearOrder ι
inst✝¹ : IsWellOrder ι fun x x_1 => x < x_1
inst✝ : (i : ι) → PartialOrder (β i)
x y : (i : ι) → β i
i✝ : ι
a✝ : β i✝
a b : (i : ι) → β i
h : a ≤ b
hne : ¬↑toLex a = ↑toLex b
i : ι
hi : i ∈ {i | a i ≠ b i}
j : ι
hj : (fun x x_1 => x < x_1) j i
hl : ↑toLex a j ≠ ↑toLex b j
⊢ ∃ x, x ∈ {i | a i ≠ b i} ∧ x < i
Theorem: RatFunc.liftOn'_div
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [RatFunc.liftOn', liftOn_div _ _ _ f0]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p q : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H : ∀ {p q a : K[X]}, q ≠ 0 → a ≠ 0 → f (a * p) (a * q) = f p q
⊢ RatFunc.liftOn' (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q) f H = f p q

tactic: apply lift_on_condition_of_lift_on'_condition H
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p q : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H : ∀ {p q a : K[X]}, q ≠ 0 → a ≠ 0 → f (a * p) (a * q) = f p q
⊢ ∀ {p q p' q' : K[X]}, q ≠ 0 → q' ≠ 0 → q' * p = q * p' → f p q = f p' q'
Theorem: TypeVec.dropFun_diag
File: Mathlib/Data/TypeVec.lean

tactic: ext i : 2
state_before: n : ℕ
α : TypeVec (n + 1)
⊢ dropFun prod.diag = prod.diag

tactic: induction i <;> simp [dropFun, *] <;> rfl
state_before: case a.h
n : ℕ
α : TypeVec (n + 1)
i : Fin2 n
x✝ : drop α i
⊢ dropFun prod.diag i x✝ = prod.diag i x✝
Theorem: Int.mul_mod_right
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm, mul_mod_left]
state_before: a b : Int
⊢ mod (a * b) a = 0
Theorem: Basis.det_unitsSMul
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: ext f
state_before: R : Type u_2
inst✝⁸ : CommRing R
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.2761525
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_1
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e✝ : Basis ι R M
A : Type ?u.2762545
inst✝¹ : CommRing A
inst✝ : Module A M
e : Basis ι R M
w : ι → Rˣ
⊢ det (unitsSMul e w) = ↑(∏ i : ι, w i)⁻¹ • det e

tactic: change
  (Matrix.det fun i j => (e.unitsSMul w).repr (f j) i) =
    (↑(∏ i, w i)⁻¹ : R) • Matrix.det fun i j => e.repr (f j) i
state_before: case H
R : Type u_2
inst✝⁸ : CommRing R
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.2761525
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_1
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e✝ : Basis ι R M
A : Type ?u.2762545
inst✝¹ : CommRing A
inst✝ : Module A M
e : Basis ι R M
w : ι → Rˣ
f : ι → M
⊢ ↑(det (unitsSMul e w)) f = ↑(↑(∏ i : ι, w i)⁻¹ • det e) f

tactic: simp only [e.repr_unitsSMul]
state_before: case H
R : Type u_2
inst✝⁸ : CommRing R
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.2761525
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_1
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e✝ : Basis ι R M
A : Type ?u.2762545
inst✝¹ : CommRing A
inst✝ : Module A M
e : Basis ι R M
w : ι → Rˣ
f : ι → M
⊢ (Matrix.det fun i j => ↑(↑(unitsSMul e w).repr (f j)) i) =
    ↑(∏ i : ι, w i)⁻¹ • Matrix.det fun i j => ↑(↑e.repr (f j)) i

tactic: convert Matrix.det_mul_column (fun i => (↑(w i)⁻¹ : R)) fun i j => e.repr (f j) i
state_before: case H
R : Type u_2
inst✝⁸ : CommRing R
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.2761525
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_1
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e✝ : Basis ι R M
A : Type ?u.2762545
inst✝¹ : CommRing A
inst✝ : Module A M
e : Basis ι R M
w : ι → Rˣ
f : ι → M
⊢ (Matrix.det fun i j => (w i)⁻¹ • ↑(↑e.repr (f j)) i) = ↑(∏ i : ι, w i)⁻¹ • Matrix.det fun i j => ↑(↑e.repr (f j)) i

tactic: simp only [← Finset.prod_inv_distrib]
state_before: case h.e'_3.h.e'_1
R : Type u_2
inst✝⁸ : CommRing R
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.2761525
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_1
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e✝ : Basis ι R M
A : Type ?u.2762545
inst✝¹ : CommRing A
inst✝ : Module A M
e : Basis ι R M
w : ι → Rˣ
f : ι → M
⊢ ↑(∏ i : ι, w i)⁻¹ = ∏ i : ι, ↑(w i)⁻¹

tactic: norm_cast
state_before: case h.e'_3.h.e'_1
R : Type u_2
inst✝⁸ : CommRing R
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.2761525
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_1
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e✝ : Basis ι R M
A : Type ?u.2762545
inst✝¹ : CommRing A
inst✝ : Module A M
e : Basis ι R M
w : ι → Rˣ
f : ι → M
⊢ ↑(∏ x : ι, (w x)⁻¹) = ∏ i : ι, ↑(w i)⁻¹
Theorem: gauge_lt_of_mem_smul
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: have : ε⁻¹ • x ∈ s := by rwa [← mem_smul_set_iff_inv_smul_mem₀ hε.ne']
state_before: 𝕜 : Type ?u.202852
E : Type u_1
F : Type ?u.202858
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
x : E
ε : ℝ
hε : 0 < ε
hs₀ : 0 ∈ s
hs₁ : Convex ℝ s
hs₂ : IsOpen s
hx : x ∈ ε • s
⊢ gauge s x < ε

tactic: have h_gauge_lt := gauge_lt_one_of_mem_of_open hs₁ hs₀ hs₂ this
state_before: 𝕜 : Type ?u.202852
E : Type u_1
F : Type ?u.202858
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
x : E
ε : ℝ
hε : 0 < ε
hs₀ : 0 ∈ s
hs₁ : Convex ℝ s
hs₂ : IsOpen s
hx : x ∈ ε • s
this : ε⁻¹ • x ∈ s
⊢ gauge s x < ε

tactic: rwa [gauge_smul_of_nonneg (inv_nonneg.2 hε.le), smul_eq_mul, inv_mul_lt_iff hε, mul_one]
  at h_gauge_lt
state_before: 𝕜 : Type ?u.202852
E : Type u_1
F : Type ?u.202858
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
x : E
ε : ℝ
hε : 0 < ε
hs₀ : 0 ∈ s
hs₁ : Convex ℝ s
hs₂ : IsOpen s
hx : x ∈ ε • s
this : ε⁻¹ • x ∈ s
h_gauge_lt : gauge s (ε⁻¹ • x) < 1
⊢ gauge s x < ε

tactic: rwa [← mem_smul_set_iff_inv_smul_mem₀ hε.ne']
state_before: 𝕜 : Type ?u.202852
E : Type u_1
F : Type ?u.202858
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
x : E
ε : ℝ
hε : 0 < ε
hs₀ : 0 ∈ s
hs₁ : Convex ℝ s
hs₂ : IsOpen s
hx : x ∈ ε • s
⊢ ε⁻¹ • x ∈ s
Theorem: closure_eq_compl_interior_compl
File: Mathlib/Topology/Basic.lean

tactic: rw [interior, closure, compl_sUnion, compl_image_set_of]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ closure s = interior (sᶜ)ᶜ

tactic: simp only [compl_subset_compl, isOpen_compl_iff]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ ⋂₀ {t | IsClosed t ∧ s ⊆ t} = ⋂₀ {s_1 | IsOpen (s_1ᶜ) ∧ s_1ᶜ ⊆ sᶜ}
Theorem: Subgroup.disjoint_iff_mul_eq_one
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simpa [hx1] using hxy
state_before: G : Type u_1
G' : Type ?u.727305
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.727314
inst✝¹ : AddGroup A
N : Type ?u.727320
inst✝ : Group N
H₁ H₂ : Subgroup G
h : ∀ {x y : G}, x ∈ H₁ → y ∈ H₂ → x = y → x = 1
x y : G
hx : x ∈ H₁
hy : y ∈ H₂
hxy : x * y = 1
hx1 : x = 1 := h hx (Subgroup.inv_mem H₂ hy) (Iff.mpr eq_inv_iff_mul_eq_one hxy)
⊢ y = 1
Theorem: Nat.ArithmeticFunction.coe_zeta_smul_apply
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [smul_apply]
state_before: R : Type u_2
M : Type u_1
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : ArithmeticFunction M
x : ℕ
⊢ ↑(↑ζ • f) x = ∑ i in divisors x, ↑f i

tactic: trans ∑ i in divisorsAntidiagonal x, f i.snd
state_before: R : Type u_2
M : Type u_1
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : ArithmeticFunction M
x : ℕ
⊢ ∑ x in divisorsAntidiagonal x, ↑↑ζ x.fst • ↑f x.snd = ∑ i in divisors x, ↑f i

tactic: refine' sum_congr rfl fun i hi => _
state_before: R : Type u_2
M : Type u_1
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : ArithmeticFunction M
x : ℕ
⊢ ∑ x in divisorsAntidiagonal x, ↑↑ζ x.fst • ↑f x.snd = ∑ i in divisorsAntidiagonal x, ↑f i.snd

tactic: rcases mem_divisorsAntidiagonal.1 hi with ⟨rfl, h⟩
state_before: R : Type u_2
M : Type u_1
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : ArithmeticFunction M
x : ℕ
i : ℕ × ℕ
hi : i ∈ divisorsAntidiagonal x
⊢ ↑↑ζ i.fst • ↑f i.snd = ↑f i.snd

tactic: rw [natCoe_apply, zeta_apply_ne (left_ne_zero_of_mul h), cast_one, one_smul]
state_before: case intro
R : Type u_2
M : Type u_1
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : ArithmeticFunction M
i : ℕ × ℕ
hi : i ∈ divisorsAntidiagonal (i.fst * i.snd)
h : i.fst * i.snd ≠ 0
⊢ ↑↑ζ i.fst • ↑f i.snd = ↑f i.snd

tactic: rw [← map_div_left_divisors, sum_map, Function.Embedding.coeFn_mk]
state_before: R : Type u_2
M : Type u_1
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : ArithmeticFunction M
x : ℕ
⊢ ∑ i in divisorsAntidiagonal x, ↑f i.snd = ∑ i in divisors x, ↑f i
Theorem: List.ofFn_add
File: Mathlib/Data/List/OfFn.lean

tactic: induction' n with n IH
state_before: α : Type u
m n : ℕ
f : Fin (m + n) → α
⊢ ofFn f = (ofFn fun i => f (↑(Fin.castAdd n) i)) ++ ofFn fun j => f (↑(Fin.natAdd m) j)

tactic: rw [ofFn_zero, append_nil, Fin.castAdd_zero, Fin.cast_refl]
state_before: case zero
α : Type u
m n : ℕ
f✝ : Fin (m + n) → α
f : Fin (m + zero) → α
⊢ ofFn f = (ofFn fun i => f (↑(Fin.castAdd zero) i)) ++ ofFn fun j => f (↑(Fin.natAdd m) j)

tactic: rfl
state_before: case zero
α : Type u
m n : ℕ
f✝ : Fin (m + n) → α
f : Fin (m + zero) → α
⊢ ofFn f = ofFn fun i => f (↑(OrderIso.refl (Fin m)) i)

tactic: rw [ofFn_succ', ofFn_succ', IH, append_concat]
state_before: case succ
α : Type u
m n✝ : ℕ
f✝ : Fin (m + n✝) → α
n : ℕ
IH : ∀ (f : Fin (m + n) → α), ofFn f = (ofFn fun i => f (↑(Fin.castAdd n) i)) ++ ofFn fun j => f (↑(Fin.natAdd m) j)
f : Fin (m + succ n) → α
⊢ ofFn f = (ofFn fun i => f (↑(Fin.castAdd (succ n)) i)) ++ ofFn fun j => f (↑(Fin.natAdd m) j)

tactic: rfl
state_before: case succ
α : Type u
m n✝ : ℕ
f✝ : Fin (m + n✝) → α
n : ℕ
IH : ∀ (f : Fin (m + n) → α), ofFn f = (ofFn fun i => f (↑(Fin.castAdd n) i)) ++ ofFn fun j => f (↑(Fin.natAdd m) j)
f : Fin (m + succ n) → α
⊢ concat ((ofFn fun i => f (↑Fin.castSucc (↑(Fin.castAdd n) i))) ++ ofFn fun j => f (↑Fin.castSucc (↑(Fin.natAdd m) j)))
      (f (Fin.last (Nat.add m n))) =
    concat ((ofFn fun i => f (↑(Fin.castAdd (succ n)) i)) ++ ofFn fun i => f (↑(Fin.natAdd m) (↑Fin.castSucc i)))
      (f (↑(Fin.natAdd m) (Fin.last n)))
Theorem: ENNReal.tsum_eq_iSup_sum'
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [ENNReal.tsum_eq_iSup_sum]
state_before: α : Type u_2
β : Type ?u.234540
γ : Type ?u.234543
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
f g : α → ℝ≥0∞
ι : Type u_1
s : ι → Finset α
hs : ∀ (t : Finset α), ∃ i, t ⊆ s i
⊢ (∑' (a : α), f a) = ⨆ (i : ι), ∑ a in s i, f a

tactic: symm
state_before: α : Type u_2
β : Type ?u.234540
γ : Type ?u.234543
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
f g : α → ℝ≥0∞
ι : Type u_1
s : ι → Finset α
hs : ∀ (t : Finset α), ∃ i, t ⊆ s i
⊢ (⨆ (s : Finset α), ∑ a in s, f a) = ⨆ (i : ι), ∑ a in s i, f a

tactic: change (⨆ i : ι, (fun t : Finset α => ∑ a in t, f a) (s i)) = ⨆ s : Finset α, ∑ a in s, f a
state_before: α : Type u_2
β : Type ?u.234540
γ : Type ?u.234543
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
f g : α → ℝ≥0∞
ι : Type u_1
s : ι → Finset α
hs : ∀ (t : Finset α), ∃ i, t ⊆ s i
⊢ (⨆ (i : ι), ∑ a in s i, f a) = ⨆ (s : Finset α), ∑ a in s, f a

tactic: exact (Finset.sum_mono_set f).iSup_comp_eq hs
state_before: α : Type u_2
β : Type ?u.234540
γ : Type ?u.234543
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
f g : α → ℝ≥0∞
ι : Type u_1
s : ι → Finset α
hs : ∀ (t : Finset α), ∃ i, t ⊆ s i
⊢ (⨆ (i : ι), (fun t => ∑ a in t, f a) (s i)) = ⨆ (s : Finset α), ∑ a in s, f a
Theorem: Bool.eq_iff_eq_true_iff
File: Mathlib/Data/Bool/Basic.lean

tactic: cases a <;> cases b <;> simp
state_before: a b : Bool
⊢ a = b ↔ (a = true ↔ b = true)
Theorem: Set.union_distrib_iInter₂_right
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [union_distrib_iInter_right]
state_before: α : Type u_1
β : Type ?u.182387
γ : Type ?u.182390
ι : Sort u_2
ι' : Sort ?u.182396
ι₂ : Sort ?u.182399
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.182409
κ₂ : ι → Sort ?u.182414
κ' : ι' → Sort ?u.182419
s : (i : ι) → κ i → Set α
t : Set α
⊢ (⋂ (i : ι) (j : κ i), s i j) ∪ t = ⋂ (i : ι) (j : κ i), s i j ∪ t
Theorem: Nat.dist_add_add_right
File: Mathlib/Data/Nat/Dist.lean

tactic: rw [@add_tsub_add_eq_tsub_right]
state_before: n k m : ℕ
⊢ n + k - (m + k) + (m + k - (n + k)) = n - m + (m + k - (n + k))

tactic: rw [@add_tsub_add_eq_tsub_right]
state_before: n k m : ℕ
⊢ n - m + (m + k - (n + k)) = n - m + (m - n)
Theorem: CategoryTheory.Limits.image.eq_fac
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: apply image.ext
state_before: C : Type u
inst✝³ : Category C
X Y : C
f f' : X ⟶ Y
inst✝² : HasImage f
inst✝¹ : HasImage f'
inst✝ : HasEqualizers C
h : f = f'
⊢ ι f = (eqToIso h).hom ≫ ι f'

tactic: dsimp [asIso,image.eqToIso, image.eqToHom]
state_before: case w
C : Type u
inst✝³ : Category C
X Y : C
f f' : X ⟶ Y
inst✝² : HasImage f
inst✝¹ : HasImage f'
inst✝ : HasEqualizers C
h : f = f'
⊢ factorThruImage f ≫ ι f = factorThruImage f ≫ (eqToIso h).hom ≫ ι f'

tactic: rw [image.lift_fac]
state_before: case w
C : Type u
inst✝³ : Category C
X Y : C
f f' : X ⟶ Y
inst✝² : HasImage f
inst✝¹ : HasImage f'
inst✝ : HasEqualizers C
h : f = f'
⊢ factorThruImage f ≫ ι f =
    factorThruImage f ≫ lift (MonoFactorisation.mk (image f') (ι f') (factorThruImage f')) ≫ ι f'
Theorem: Nat.ofDigits_one
File: Mathlib/Data/Nat/Digits.lean

tactic: induction' L with _ _ ih
state_before: n : ℕ
L : List ℕ
⊢ ofDigits 1 L = List.sum L

tactic: rfl
state_before: case nil
n : ℕ
⊢ ofDigits 1 [] = List.sum []

tactic: simp [ofDigits, List.sum_cons, ih]
state_before: case cons
n head✝ : ℕ
tail✝ : List ℕ
ih : ofDigits 1 tail✝ = List.sum tail✝
⊢ ofDigits 1 (head✝ :: tail✝) = List.sum (head✝ :: tail✝)
Theorem: ENNReal.toReal_sub_of_le
File: Mathlib/Data/Real/ENNReal.lean

tactic: lift b to ℝ≥0 using ne_top_of_le_ne_top ha h
state_before: α : Type ?u.790750
β : Type ?u.790753
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
h : b ≤ a
ha : a ≠ ⊤
⊢ ENNReal.toReal (a - b) = ENNReal.toReal a - ENNReal.toReal b

tactic: lift a to ℝ≥0 using ha
state_before: case intro
α : Type ?u.790750
β : Type ?u.790753
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
ha : a ≠ ⊤
b : ℝ≥0
h : ↑b ≤ a
⊢ ENNReal.toReal (a - ↑b) = ENNReal.toReal a - ENNReal.toReal ↑b

tactic: simp only [← ENNReal.coe_sub, ENNReal.coe_toReal, NNReal.coe_sub (ENNReal.coe_le_coe.mp h)]
state_before: case intro.intro
α : Type ?u.790750
β : Type ?u.790753
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
h : ↑b ≤ ↑a
⊢ ENNReal.toReal (↑a - ↑b) = ENNReal.toReal ↑a - ENNReal.toReal ↑b
Theorem: List.mem_reverse
File: Std/Data/List/Lemmas.lean

tactic: simp [reverse]
state_before: α : Type u_1
x : α
as : List α
⊢ x ∈ reverse as ↔ x ∈ as
Theorem: ContinuousLinearMap.norm_iteratedFDeriv_le_of_bilinear_of_le_one
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp_rw [← iteratedFDerivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.4106125
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : D
n : ℕ
hn : ↑n ≤ N
hB : ‖B‖ ≤ 1
⊢ ‖iteratedFDeriv 𝕜 n (fun y => ↑(↑B (f y)) (g y)) x‖ ≤
    ∑ i in Finset.range (n + 1), ↑(Nat.choose n i) * ‖iteratedFDeriv 𝕜 i f x‖ * ‖iteratedFDeriv 𝕜 (n - i) g x‖

tactic: exact B.norm_iteratedFDerivWithin_le_of_bilinear_of_le_one hf.contDiffOn hg.contDiffOn
  uniqueDiffOn_univ (mem_univ x) hn hB
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.4106125
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : D
n : ℕ
hn : ↑n ≤ N
hB : ‖B‖ ≤ 1
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) univ x‖ ≤
    ∑ x_1 in Finset.range (n + 1),
      ↑(Nat.choose n x_1) * ‖iteratedFDerivWithin 𝕜 x_1 f univ x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g univ x‖
Theorem: tsum_eq_zero_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

tactic: rw [← hasSum_zero_iff, hf.hasSum_iff]
state_before: ι : Type u_2
κ : Type ?u.53822
α : Type u_1
inst✝² : CanonicallyOrderedAddMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f : ι → α
a : α
hf : Summable f
⊢ (∑' (i : ι), f i) = 0 ↔ ∀ (x : ι), f x = 0
Theorem: Int.natAbs_ediv
File: Mathlib/Data/Int/GCD.lean

tactic: rcases Nat.eq_zero_or_pos (natAbs b) with (h | h)
state_before: a b : ℤ
H : b ∣ a
⊢ natAbs (a / b) = natAbs a / natAbs b

tactic: rw [natAbs_eq_zero.1 h]
state_before: case inl
a b : ℤ
H : b ∣ a
h : natAbs b = 0
⊢ natAbs (a / b) = natAbs a / natAbs b

case inr
a b : ℤ
H : b ∣ a
h : natAbs b > 0
⊢ natAbs (a / b) = natAbs a / natAbs b

tactic: simp [Int.ediv_zero]
state_before: case inl
a b : ℤ
H : b ∣ a
h : natAbs b = 0
⊢ natAbs (a / 0) = natAbs a / natAbs 0

case inr
a b : ℤ
H : b ∣ a
h : natAbs b > 0
⊢ natAbs (a / b) = natAbs a / natAbs b

tactic: calc
  natAbs (a / b) = natAbs (a / b) * 1 := by rw [mul_one]
  _ = natAbs (a / b) * (natAbs b / natAbs b) := by rw [Nat.div_self h]
  _ = natAbs (a / b) * natAbs b / natAbs b := by rw [Nat.mul_div_assoc _ dvd_rfl]
  _ = natAbs (a / b * b) / natAbs b := by rw [natAbs_mul (a / b) b]
  _ = natAbs a / natAbs b := by rw [Int.ediv_mul_cancel H]
state_before: case inr
a b : ℤ
H : b ∣ a
h : natAbs b > 0
⊢ natAbs (a / b) = natAbs a / natAbs b

tactic: rw [mul_one]
state_before: a b : ℤ
H : b ∣ a
h : natAbs b > 0
⊢ natAbs (a / b) = natAbs (a / b) * 1

tactic: rw [Nat.div_self h]
state_before: a b : ℤ
H : b ∣ a
h : natAbs b > 0
⊢ natAbs (a / b) * 1 = natAbs (a / b) * (natAbs b / natAbs b)

tactic: rw [Nat.mul_div_assoc _ dvd_rfl]
state_before: a b : ℤ
H : b ∣ a
h : natAbs b > 0
⊢ natAbs (a / b) * (natAbs b / natAbs b) = natAbs (a / b) * natAbs b / natAbs b

tactic: rw [natAbs_mul (a / b) b]
state_before: a b : ℤ
H : b ∣ a
h : natAbs b > 0
⊢ natAbs (a / b) * natAbs b / natAbs b = natAbs (a / b * b) / natAbs b

tactic: rw [Int.ediv_mul_cancel H]
state_before: a b : ℤ
H : b ∣ a
h : natAbs b > 0
⊢ natAbs (a / b * b) / natAbs b = natAbs a / natAbs b
Theorem: HolorIndex.drop_take
File: Mathlib/Data/Holor.lean

tactic: simp [assocRight, take, drop, cast_type, List.drop_take]
state_before: ds₁ ds₂ ds₃ is : List ℕ
h : Forall₂ (fun x x_1 => x < x_1) is (ds₁ ++ ds₂ ++ ds₃)
⊢ ↑(take (drop (assocRight { val := is, property := h }))) = ↑(drop (take { val := is, property := h }))
Theorem: Set.image2_inter_union_subset_union
File: Mathlib/Data/Set/NAry.lean

tactic: rw [image2_union_right]
state_before: α : Type u_2
α' : Type ?u.49775
β : Type u_3
β' : Type ?u.49781
γ : Type u_1
γ' : Type ?u.49787
δ : Type ?u.49790
δ' : Type ?u.49793
ε : Type ?u.49796
ε' : Type ?u.49799
ζ : Type ?u.49802
ζ' : Type ?u.49805
ν : Type ?u.49808
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f (s ∩ s') (t ∪ t') ⊆ image2 f s t ∪ image2 f s' t'

tactic: exact
  union_subset_union (image2_subset_right <| inter_subset_left _ _)
    (image2_subset_right <| inter_subset_right _ _)
state_before: α : Type u_2
α' : Type ?u.49775
β : Type u_3
β' : Type ?u.49781
γ : Type u_1
γ' : Type ?u.49787
δ : Type ?u.49790
δ' : Type ?u.49793
ε : Type ?u.49796
ε' : Type ?u.49799
ζ : Type ?u.49802
ζ' : Type ?u.49805
ν : Type ?u.49808
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f (s ∩ s') t ∪ image2 f (s ∩ s') t' ⊆ image2 f s t ∪ image2 f s' t'