tasksource/leandojo huggingface dataset:
Theorem: ContinuousLinearMap.apply_norm_sq_eq_inner_adjoint_left
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: have h : ⟪(A† * A) x, x⟫ = ⟪A x, A x⟫ := by rw [← adjoint_inner_left]; rfl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.519553
G : Type ?u.519556
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
A : E →L[𝕜] E
x : E
⊢ ‖↑A x‖ ^ 2 = ↑re (inner (↑(↑adjoint A * A) x) x)

tactic: rw [h, ← inner_self_eq_norm_sq (𝕜 := 𝕜) _]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.519553
G : Type ?u.519556
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
A : E →L[𝕜] E
x : E
h : inner (↑(↑adjoint A * A) x) x = inner (↑A x) (↑A x)
⊢ ‖↑A x‖ ^ 2 = ↑re (inner (↑(↑adjoint A * A) x) x)

tactic: rw [← adjoint_inner_left]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.519553
G : Type ?u.519556
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
A : E →L[𝕜] E
x : E
⊢ inner (↑(↑adjoint A * A) x) x = inner (↑A x) (↑A x)

tactic: rfl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.519553
G : Type ?u.519556
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
A : E →L[𝕜] E
x : E
⊢ inner (↑(↑adjoint A * A) x) x = inner (↑(↑adjoint A) (↑A x)) x
Theorem: Ordinal.iSup_ord
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: unfold iSup
state_before: α : Type ?u.302906
β : Type ?u.302909
γ : Type ?u.302912
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Sort u_1
f : ι → Cardinal
hf : BddAbove (range f)
⊢ ord (iSup f) = ⨆ (i : ι), ord (f i)

tactic: convert sSup_ord hf
state_before: α : Type ?u.302906
β : Type ?u.302909
γ : Type ?u.302912
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Sort u_1
f : ι → Cardinal
hf : BddAbove (range f)
⊢ ord (sSup (range f)) = sSup (range fun i => ord (f i))

tactic: conv_lhs => change range (ord ∘ f)
state_before: case h.e'_3.h.e'_3
α : Type ?u.302906
β : Type ?u.302909
γ : Type ?u.302912
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Sort u_1
f : ι → Cardinal
hf : BddAbove (range f)
⊢ (range fun i => ord (f i)) = ord '' range f

tactic: rw [range_comp]
state_before: case h.e'_3.h.e'_3
α : Type ?u.302906
β : Type ?u.302909
γ : Type ?u.302912
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Sort u_1
f : ι → Cardinal
hf : BddAbove (range f)
⊢ range (ord ∘ f) = ord '' range f
Theorem: GroupFilterBasis.nhds_one_hasBasis
File: Mathlib/Topology/Algebra/FilterBasis.lean

tactic: rw [B.nhds_one_eq]
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ HasBasis (𝓝 1) (fun V => V ∈ B) id

tactic: exact B.toFilterBasis.hasBasis
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ HasBasis (FilterBasis.filter toFilterBasis) (fun V => V ∈ B) id
Theorem: lt_max_of_sq_lt_mul
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simpa using min_lt_max_of_mul_lt_mul ((pow_two _).symm.trans_lt h)
state_before: β : Type ?u.157025
A : Type ?u.157028
G : Type ?u.157031
M : Type u_1
R : Type ?u.157037
inst✝³ : Monoid M
inst✝² : LinearOrder M
inst✝¹ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : M
h : a ^ 2 < b * c
⊢ a < max b c
Theorem: Matrix.isHermitian_inv
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: rw [← inv_inv_of_invertible A]
state_before: α : Type u_2
β : Type ?u.47971
m : Type u_1
n : Type ?u.47977
A✝ : Matrix n n α
inst✝⁴ : CommRing α
inst✝³ : StarRing α
inst✝² : Fintype m
inst✝¹ : DecidableEq m
A : Matrix m m α
inst✝ : Invertible A
h : IsHermitian A⁻¹
⊢ IsHermitian A

tactic: exact IsHermitian.inv h
state_before: α : Type u_2
β : Type ?u.47971
m : Type u_1
n : Type ?u.47977
A✝ : Matrix n n α
inst✝⁴ : CommRing α
inst✝³ : StarRing α
inst✝² : Fintype m
inst✝¹ : DecidableEq m
A : Matrix m m α
inst✝ : Invertible A
h : IsHermitian A⁻¹
⊢ IsHermitian A⁻¹⁻¹
Theorem: Finsupp.support_sub
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rw [sub_eq_add_neg, ← support_neg g]
state_before: α : Type u_1
β : Type ?u.559184
γ : Type ?u.559187
ι : Type ?u.559190
M : Type ?u.559193
M' : Type ?u.559196
N : Type ?u.559199
P : Type ?u.559202
G : Type u_2
H : Type ?u.559208
R : Type ?u.559211
S : Type ?u.559214
inst✝¹ : DecidableEq α
inst✝ : AddGroup G
f g : α →₀ G
⊢ (f - g).support ⊆ f.support ∪ g.support

tactic: exact support_add
state_before: α : Type u_1
β : Type ?u.559184
γ : Type ?u.559187
ι : Type ?u.559190
M : Type ?u.559193
M' : Type ?u.559196
N : Type ?u.559199
P : Type ?u.559202
G : Type u_2
H : Type ?u.559208
R : Type ?u.559211
S : Type ?u.559214
inst✝¹ : DecidableEq α
inst✝ : AddGroup G
f g : α →₀ G
⊢ (f + -g).support ⊆ f.support ∪ (-g).support
Theorem: Matrix.vecAlt0_vecAppend
File: Mathlib/Data/Fin/VecNotation.lean

tactic: ext i
state_before: α : Type u
m n o : ℕ
m' : Type ?u.38823
n' : Type ?u.38826
o' : Type ?u.38829
v : Fin n → α
⊢ vecAlt0 (_ : n + n = n + n) (vecAppend (_ : n + n = n + n) v v) = v ∘ bit0

tactic: simp_rw [Function.comp, bit0, vecAlt0, vecAppend_eq_ite]
state_before: case h
α : Type u
m n o : ℕ
m' : Type ?u.38823
n' : Type ?u.38826
o' : Type ?u.38829
v : Fin n → α
i : Fin n
⊢ vecAlt0 (_ : n + n = n + n) (vecAppend (_ : n + n = n + n) v v) i = (v ∘ bit0) i

tactic: split_ifs with h <;> congr
state_before: case h
α : Type u
m n o : ℕ
m' : Type ?u.38823
n' : Type ?u.38826
o' : Type ?u.38829
v : Fin n → α
i : Fin n
⊢ (if h : ↑i + ↑i < n then v { val := ↑i + ↑i, isLt := (_ : ↑{ val := ↑i + ↑i, isLt := (_ : ↑i + ↑i < n + n) } < n) }
    else v { val := ↑i + ↑i - n, isLt := (_ : ↑{ val := ↑i + ↑i, isLt := (_ : ↑i + ↑i < n + n) } - n < n) }) =
    v (i + i)

tactic: rw [Fin.val_mk] at h
state_before: case h.inl.e_a.e_val
α : Type u
m n o : ℕ
m' : Type ?u.38823
n' : Type ?u.38826
o' : Type ?u.38829
v : Fin n → α
i : Fin n
h : ↑i + ↑i < n
⊢ ↑i + ↑i = (↑i + ↑i) % n

tactic: simp only [Fin.ext_iff, Fin.val_add, Fin.val_mk]
state_before: case h.inl.e_a.e_val
α : Type u
m n o : ℕ
m' : Type ?u.38823
n' : Type ?u.38826
o' : Type ?u.38829
v : Fin n → α
i : Fin n
h : ↑i + ↑i < n
⊢ ↑i + ↑i = (↑i + ↑i) % n

tactic: exact (Nat.mod_eq_of_lt h).symm
state_before: case h.inl.e_a.e_val
α : Type u
m n o : ℕ
m' : Type ?u.38823
n' : Type ?u.38826
o' : Type ?u.38829
v : Fin n → α
i : Fin n
h : ↑i + ↑i < n
⊢ ↑i + ↑i = (↑i + ↑i) % n

tactic: rw [Fin.val_mk, not_lt] at h
state_before: case h.inr.e_a.e_val
α : Type u
m n o : ℕ
m' : Type ?u.38823
n' : Type ?u.38826
o' : Type ?u.38829
v : Fin n → α
i : Fin n
h : ¬↑i + ↑i < n
⊢ ↑i + ↑i - n = (↑i + ↑i) % n

tactic: simp only [Fin.ext_iff, Fin.val_add, Fin.val_mk, Nat.mod_eq_sub_mod h]
state_before: case h.inr.e_a.e_val
α : Type u
m n o : ℕ
m' : Type ?u.38823
n' : Type ?u.38826
o' : Type ?u.38829
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i - n = (↑i + ↑i) % n

tactic: refine' (Nat.mod_eq_of_lt _).symm
state_before: case h.inr.e_a.e_val
α : Type u
m n o : ℕ
m' : Type ?u.38823
n' : Type ?u.38826
o' : Type ?u.38829
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i - n = (↑i + ↑i - n) % n

tactic: rw [tsub_lt_iff_left h]
state_before: case h.inr.e_a.e_val
α : Type u
m n o : ℕ
m' : Type ?u.38823
n' : Type ?u.38826
o' : Type ?u.38829
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i - n < n

tactic: exact add_lt_add i.2 i.2
state_before: case h.inr.e_a.e_val
α : Type u
m n o : ℕ
m' : Type ?u.38823
n' : Type ?u.38826
o' : Type ?u.38829
v : Fin n → α
i : Fin n
h : n ≤ ↑i + ↑i
⊢ ↑i + ↑i < n + n
Theorem: Set.Ioo_union_Ioo'
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: ext1 x
state_before: α : Type u_1
β : Type ?u.164237
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
h₂ : a < d
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)

tactic: simp_rw [mem_union, mem_Ioo, min_lt_iff, lt_max_iff]
state_before: case h
α : Type u_1
β : Type ?u.164237
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
h₂ : a < d
x : α
⊢ x ∈ Ioo a b ∪ Ioo c d ↔ x ∈ Ioo (min a c) (max b d)

tactic: by_cases hc : c < x <;> by_cases hd : x < d
state_before: case h
α : Type u_1
β : Type ?u.164237
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
h₂ : a < d
x : α
⊢ a < x ∧ x < b ∨ c < x ∧ x < d ↔ (a < x ∨ c < x) ∧ (x < b ∨ x < d)

tactic: simp only [hc, hd, and_self, or_true]
state_before: case pos
α : Type u_1
β : Type ?u.164237
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
h₂ : a < d
x : α
hc : c < x
hd : x < d
⊢ a < x ∧ x < b ∨ c < x ∧ x < d ↔ (a < x ∨ c < x) ∧ (x < b ∨ x < d)

tactic: have hax : a < x := h₂.trans_le (le_of_not_lt hd)
state_before: case neg
α : Type u_1
β : Type ?u.164237
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
h₂ : a < d
x : α
hc : c < x
hd : ¬x < d
⊢ a < x ∧ x < b ∨ c < x ∧ x < d ↔ (a < x ∨ c < x) ∧ (x < b ∨ x < d)

tactic: simp only [hax, true_and, hc, or_self]
state_before: case neg
α : Type u_1
β : Type ?u.164237
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
h₂ : a < d
x : α
hc : c < x
hd : ¬x < d
hax : a < x
⊢ a < x ∧ x < b ∨ c < x ∧ x < d ↔ (a < x ∨ c < x) ∧ (x < b ∨ x < d)

tactic: have hxb : x < b := (le_of_not_lt hc).trans_lt h₁
state_before: case pos
α : Type u_1
β : Type ?u.164237
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
h₂ : a < d
x : α
hc : ¬c < x
hd : x < d
⊢ a < x ∧ x < b ∨ c < x ∧ x < d ↔ (a < x ∨ c < x) ∧ (x < b ∨ x < d)

tactic: simp only [hxb, and_true, hc, false_and, or_false, true_or]
state_before: case pos
α : Type u_1
β : Type ?u.164237
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
h₂ : a < d
x : α
hc : ¬c < x
hd : x < d
hxb : x < b
⊢ a < x ∧ x < b ∨ c < x ∧ x < d ↔ (a < x ∨ c < x) ∧ (x < b ∨ x < d)

tactic: simp only [hc, hd, and_self, or_false]
state_before: case neg
α : Type u_1
β : Type ?u.164237
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
h₂ : a < d
x : α
hc : ¬c < x
hd : ¬x < d
⊢ a < x ∧ x < b ∨ c < x ∧ x < d ↔ (a < x ∨ c < x) ∧ (x < b ∨ x < d)
Theorem: CategoryTheory.SimplicialObject.δ_comp_σ_succ
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ σ X i ≫ δ X (Fin.succ i) = 𝟙 (X.obj [n].op)

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_succ, op_id, X.map_id]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.map (SimplexCategory.σ i).op ≫ X.map (SimplexCategory.δ (Fin.succ i)).op = 𝟙 (X.obj [n].op)
Theorem: associated_unit_mul_left
File: Mathlib/Algebra/Associated.lean

tactic: rw [mul_comm]
state_before: α : Type ?u.161759
β✝ : Type ?u.161762
γ : Type ?u.161765
δ : Type ?u.161768
β : Type u_1
inst✝ : CommMonoid β
a u : β
hu : IsUnit u
⊢ u * a ~ᵤ a

tactic: exact associated_mul_unit_left _ _ hu
state_before: α : Type ?u.161759
β✝ : Type ?u.161762
γ : Type ?u.161765
δ : Type ?u.161768
β : Type u_1
inst✝ : CommMonoid β
a u : β
hu : IsUnit u
⊢ a * u ~ᵤ a
Theorem: Basis.total_dualBasis
File: Mathlib/LinearAlgebra/Dual.lean

tactic: cases nonempty_fintype ι
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : ι →₀ R
i : ι
⊢ ↑(↑(Finsupp.total ι (Dual R M) R ↑(dualBasis b)) f) (↑b i) = ↑f i

tactic: rw [Finsupp.total_apply, Finsupp.sum_fintype, LinearMap.sum_apply]
state_before: case intro
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : ι →₀ R
i : ι
val✝ : Fintype ι
⊢ ↑(↑(Finsupp.total ι (Dual R M) R ↑(dualBasis b)) f) (↑b i) = ↑f i

tactic: simp_rw [LinearMap.smul_apply, smul_eq_mul, dualBasis_apply_self, mul_boole,
Finset.sum_ite_eq, if_pos (Finset.mem_univ i)]
state_before: case intro
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : ι →₀ R
i : ι
val✝ : Fintype ι
⊢ ∑ d : ι, ↑(↑f d • ↑(dualBasis b) d) (↑b i) = ↑f i

tactic: intro
state_before: case intro.h
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : ι →₀ R
i : ι
val✝ : Fintype ι
⊢ ∀ (i : ι), 0 • ↑(dualBasis b) i = 0

tactic: rw [zero_smul]
state_before: case intro.h
R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : ι →₀ R
i : ι
val✝ : Fintype ι
i✝ : ι
⊢ 0 • ↑(dualBasis b) i✝ = 0
Theorem: Ordinal.le_of_dvd
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: subst e
state_before: α : Type ?u.252332
β : Type ?u.252335
γ : Type ?u.252338
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a x✝ : Ordinal
b0 : x✝ ≠ 0
b : Ordinal
e : x✝ = a * b
⊢ a ≤ x✝

tactic: simpa only [mul_one] using
  mul_le_mul_left'
    (one_le_iff_ne_zero.2 fun h : b = 0 => by simp only [h, mul_zero, Ne] at b0) a
state_before: α : Type ?u.252332
β : Type ?u.252335
γ : Type ?u.252338
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
b0 : a * b ≠ 0
⊢ a ≤ a * b

tactic: simp only [h, mul_zero, Ne] at b0
state_before: α : Type ?u.252332
β : Type ?u.252335
γ : Type ?u.252338
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
b0 : a * b ≠ 0
h : b = 0
⊢ False
Theorem: EReal.eq_bot_iff_forall_lt
File: Mathlib/Data/Real/EReal.lean

tactic: constructor
state_before: x : EReal
⊢ x = ⊥ ↔ ∀ (y : ℝ), x < ↑y

tactic: rintro rfl
state_before: case mp
x : EReal
⊢ x = ⊥ → ∀ (y : ℝ), x < ↑y

tactic: exact bot_lt_coe
state_before: case mp

⊢ ∀ (y : ℝ), ⊥ < ↑y

tactic: contrapose!
state_before: case mpr
x : EReal
⊢ (∀ (y : ℝ), x < ↑y) → x = ⊥

tactic: intro h
state_before: case mpr
x : EReal
⊢ x ≠ ⊥ → ∃ y, ↑y ≤ x

tactic: exact ⟨x.toReal, coe_toReal_le h⟩
state_before: case mpr
x : EReal
h : x ≠ ⊥
⊢ ∃ y, ↑y ≤ x
Theorem: Multiset.filter_filter
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.266278
γ : Type ?u.266281
p : α → Prop
inst✝¹ : DecidablePred p
q : α → Prop
inst✝ : DecidablePred q
s : Multiset α
l : List α
⊢ filter p (filter q (Quot.mk Setoid.r l)) = filter (fun a => p a ∧ q a) (Quot.mk Setoid.r l)
Theorem: List.range'_eq_nil
File: Std/Data/List/Lemmas.lean

tactic: rw [← length_eq_zero, length_range']
state_before: s n step : Nat
⊢ range' s n step = [] ↔ n = 0
Theorem: CategoryTheory.tensorRightHomEquiv_symm_coevaluation_comp_id_tensor
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: dsimp [tensorRightHomEquiv, leftAdjointMate]
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ ↑(tensorRightHomEquiv (𝟙_ C) (ᘁY) Y ᘁX).symm (η_ (ᘁX) X ≫ (𝟙 ᘁX ⊗ f)) = (λ_ ᘁY).hom ≫ ᘁf

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (η_ (ᘁX) X ≫ (𝟙 ᘁX ⊗ f) ⊗ 𝟙 ᘁY) ≫ (α_ (ᘁX) Y ᘁY).hom ≫ (𝟙 ᘁX ⊗ ε_ (ᘁY) Y) ≫ (ρ_ ᘁX).hom =
    (λ_ ᘁY).hom ≫
      (λ_ ᘁY).inv ≫ (η_ (ᘁX) X ⊗ 𝟙 ᘁY) ≫ ((𝟙 ᘁX ⊗ f) ⊗ 𝟙 ᘁY) ≫ (α_ (ᘁX) Y ᘁY).hom ≫ (𝟙 ᘁX ⊗ ε_ (ᘁY) Y) ≫ (ρ_ ᘁX).hom
Theorem: Submonoid.coe_topologicalClosure
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: rfl
state_before: ι : Type ?u.147412
α : Type ?u.147415
X : Type ?u.147418
M : Type u_1
N : Type ?u.147424
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
s : Submonoid M
⊢ ↑(topologicalClosure s) = _root_.closure ↑s
Theorem: IsAlgClosed.cardinal_eq_cardinal_transcendence_basis_of_aleph0_lt
File: Mathlib/FieldTheory/IsAlgClosed/Classification.lean

tactic: rw [max_eq_left, max_eq_right]
state_before: R L K : Type u
inst✝⁴ : CommRing R
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsAlgClosed K
ι : Type u
v : ι → K
hv✝ : IsTranscendenceBasis R v
inst✝ : Nontrivial R
hv : IsTranscendenceBasis R v
hR : (#R) ≤ ℵ₀
hK : ℵ₀ < (#K)
this : ℵ₀ ≤ (#ι)
⊢ max (max (#R) (#ι)) ℵ₀ = (#ι)

tactic: exact le_trans hR this
state_before: R L K : Type u
inst✝⁴ : CommRing R
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsAlgClosed K
ι : Type u
v : ι → K
hv✝ : IsTranscendenceBasis R v
inst✝ : Nontrivial R
hv : IsTranscendenceBasis R v
hR : (#R) ≤ ℵ₀
hK : ℵ₀ < (#K)
this : ℵ₀ ≤ (#ι)
⊢ (#R) ≤ (#ι)

tactic: exact le_max_of_le_right this
state_before: R L K : Type u
inst✝⁴ : CommRing R
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsAlgClosed K
ι : Type u
v : ι → K
hv✝ : IsTranscendenceBasis R v
inst✝ : Nontrivial R
hv : IsTranscendenceBasis R v
hR : (#R) ≤ ℵ₀
hK : ℵ₀ < (#K)
this : ℵ₀ ≤ (#ι)
⊢ ℵ₀ ≤ max (#R) (#ι)
Theorem: Submodule.card_eq_card_quotient_mul_card
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: rw [mul_comm, ← Fintype.card_prod]
state_before: R : Type u_2
M : Type u_1
r : R
x y : M
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p p' : Submodule R M
inst✝¹ : Fintype M
S : Submodule R M
inst✝ : DecidablePred fun x => x ∈ S
⊢ Fintype.card M = Fintype.card { x // x ∈ S } * Fintype.card (M ⧸ S)

tactic: exact Fintype.card_congr AddSubgroup.addGroupEquivQuotientProdAddSubgroup
state_before: R : Type u_2
M : Type u_1
r : R
x y : M
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
p p' : Submodule R M
inst✝¹ : Fintype M
S : Submodule R M
inst✝ : DecidablePred fun x => x ∈ S
⊢ Fintype.card M = Fintype.card ((M ⧸ S) × { x // x ∈ S })
Theorem: Finset.image_singleton
File: Mathlib/Data/Finset/Image.lean

tactic: simpa only [mem_image, exists_prop, mem_singleton, exists_eq_left] using eq_comm
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.89300
inst✝ : DecidableEq β
f✝ g : α → β
s : Finset α
t : Finset β
a✝ : α
b c : β
f : α → β
a : α
x : β
⊢ x ∈ image f {a} ↔ x ∈ {f a}
Theorem: QuotientAddGroup.norm_lt_iff
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: rw [isGLB_lt_iff (isGLB_quotient_norm _), bex_image_iff]
state_before: M : Type u_1
N : Type ?u.194075
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
r : ℝ
⊢ ‖x‖ < r ↔ ∃ m, ↑m = x ∧ ‖m‖ < r

tactic: rfl
state_before: M : Type u_1
N : Type ?u.194075
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
r : ℝ
⊢ (∃ x_1, x_1 ∈ {m | ↑(mk' S) m = x} ∧ ‖x_1‖ < r) ↔ ∃ m, ↑m = x ∧ ‖m‖ < r
Theorem: IsLowerSet.cthickening'
File: Mathlib/Analysis/Normed/Order/UpperLower.lean

tactic: rw [cthickening_eq_iInter_thickening'']
state_before: α : Type u_1
ι : Type ?u.1902
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsLowerSet s
ε : ℝ
⊢ IsLowerSet (cthickening ε s)

tactic: exact isLowerSet_iInter₂ fun δ _ => hs.thickening' _
state_before: α : Type u_1
ι : Type ?u.1902
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsLowerSet s
ε : ℝ
⊢ IsLowerSet (⋂ (ε_1 : ℝ) (_ : max 0 ε < ε_1), thickening ε_1 s)
Theorem: Nat.Partrec'.cons
File: Mathlib/Computability/Halting.lean

tactic: simpa using hf
state_before: n m : ℕ
f : Vector ℕ n → ℕ
g : Vector ℕ n → Vector ℕ m
hf : Partrec' ↑f
hg : Vec g
i : Fin (succ m)
⊢ Partrec' fun v => ↑(some (Vector.get ((fun v => f v ::ᵥ g v) v) 0))

tactic: simp only [hg i, get_cons_succ]
state_before: n m : ℕ
f : Vector ℕ n → ℕ
g : Vector ℕ n → Vector ℕ m
hf : Partrec' ↑f
hg : Vec g
i✝ : Fin (succ m)
i : Fin m
⊢ Partrec' fun v => ↑(some (Vector.get ((fun v => f v ::ᵥ g v) v) (Fin.succ i)))
Theorem: PFunctor.M.isPath_cons
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: generalize h : M.mk ⟨a, f⟩ = x
state_before: F : PFunctor
X : Type ?u.20790
f✝ : X → Obj F X
xs : Path F
a a' : F.A
f : B F a → M F
i : B F a'
⊢ IsPath ({ fst := a', snd := i } :: xs) (M.mk { fst := a, snd := f }) → a = a'

tactic: rintro (_ | ⟨_, _, _, _, rfl, _⟩)
state_before: F : PFunctor
X : Type ?u.20790
f✝ : X → Obj F X
xs : Path F
a a' : F.A
f : B F a → M F
i : B F a'
x : M F
h : M.mk { fst := a, snd := f } = x
⊢ IsPath ({ fst := a', snd := i } :: xs) x → a = a'

tactic: cases mk_inj h
state_before: case cons
F : PFunctor
X : Type ?u.20790
f✝¹ : X → Obj F X
xs : Path F
a a' : F.A
f : B F a → M F
i : B F a'
f✝ : B F a' → M F
a✝ : IsPath xs (f✝ i)
h : M.mk { fst := a, snd := f } = M.mk { fst := a', snd := f✝ }
⊢ a = a'

tactic: rfl
state_before: case cons.refl
F : PFunctor
X : Type ?u.20790
f✝ : X → Obj F X
xs : Path F
a : F.A
f : B F a → M F
i : B F a
a✝ : IsPath xs (f i)
h : M.mk { fst := a, snd := f } = M.mk { fst := a, snd := f }
⊢ a = a
Theorem: Finset.mul_zero_subset
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp [subset_iff, mem_mul]
state_before: F : Type ?u.581097
α : Type u_1
β : Type ?u.581103
γ : Type ?u.581106
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : MulZeroClass α
s✝ t s : Finset α
⊢ s * 0 ⊆ 0
Theorem: MvPolynomial.isHomogeneous_C
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: apply isHomogeneous_monomial
state_before: σ : Type u_1
τ : Type ?u.129675
R : Type u_2
S : Type ?u.129681
inst✝ : CommSemiring R
r : R
⊢ IsHomogeneous (↑C r) 0

tactic: simp only [Finsupp.zero_apply, Finset.sum_const_zero]
state_before: case hn
σ : Type u_1
τ : Type ?u.129675
R : Type u_2
S : Type ?u.129681
inst✝ : CommSemiring R
r : R
⊢ ∑ i in 0.support, ↑0 i = 0
Theorem: Rat.toNNRat_lt_iff_lt_coe
File: Mathlib/Data/Rat/NNRat.lean

tactic: rw [← coe_lt_coe, Rat.coe_toNNRat q hq]
state_before: p✝ q : ℚ
p : ℚ≥0
hq : 0 ≤ q
⊢ toNNRat q < p ↔ q < ↑p
Theorem: le_div_self_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: simp only [div_eq_mul_inv, le_mul_iff_one_le_right', Left.one_le_inv_iff]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c d a b : α
⊢ a ≤ a / b ↔ b ≤ 1
Theorem: AlgebraicGeometry.StructureSheaf.IsFraction.eq_mk'
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: rcases hf with ⟨r, s, h⟩
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
f : (x : { x // x ∈ U }) → Localizations R ↑x
hf : IsFraction f
⊢ ∃ r s,
    ∀ (x : { x // x ∈ U }),
      ∃ hs, f x = IsLocalization.mk' (Localization.AtPrime (↑x).asIdeal) r { val := s, property := hs }

tactic: refine' ⟨r, s, fun x => ⟨(h x).1, (IsLocalization.mk'_eq_iff_eq_mul.mpr _).symm⟩⟩
state_before: case intro.intro
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
f : (x : { x // x ∈ U }) → Localizations R ↑x
r s : R
h :
  ∀ (x : { x // x ∈ U }),
    ¬s ∈ (↑x).asIdeal ∧ f x * ↑(algebraMap R (Localizations R ↑x)) s = ↑(algebraMap R (Localizations R ↑x)) r
⊢ ∃ r s,
    ∀ (x : { x // x ∈ U }),
      ∃ hs, f x = IsLocalization.mk' (Localization.AtPrime (↑x).asIdeal) r { val := s, property := hs }

tactic: exact (h x).2.symm
state_before: case intro.intro
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
f : (x : { x // x ∈ U }) → Localizations R ↑x
r s : R
h :
  ∀ (x : { x // x ∈ U }),
    ¬s ∈ (↑x).asIdeal ∧ f x * ↑(algebraMap R (Localizations R ↑x)) s = ↑(algebraMap R (Localizations R ↑x)) r
x : { x // x ∈ U }
⊢ ↑(algebraMap R (Localizations R ↑x)) r =
    f x * ↑(algebraMap R (Localizations R ↑x)) ↑{ val := s, property := (_ : ¬s ∈ (↑x).asIdeal) }