tasksource/leandojo huggingface dataset:
Theorem: exists_dist_lt_lt
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: refine' (exists_dist_eq x z (div_nonneg hε.le <| add_nonneg hε.le hδ.le)
  (div_nonneg hδ.le <| add_nonneg hε.le hδ.le) <| by
    rw [← add_div, div_self (add_pos hε hδ).ne']).imp
  fun y hy => _
state_before: 𝕜 : Type ?u.213757
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hδ : 0 < δ
hε : 0 < ε
h : dist x z < ε + δ
⊢ ∃ y, dist x y < δ ∧ dist y z < ε

tactic: rw [hy.1, hy.2, div_mul_comm, div_mul_comm ε]
state_before: 𝕜 : Type ?u.213757
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y✝ z : E
δ ε : ℝ
hδ : 0 < δ
hε : 0 < ε
h : dist x z < ε + δ
y : E
hy : dist x y = δ / (ε + δ) * dist x z ∧ dist y z = ε / (ε + δ) * dist x z
⊢ dist x y < δ ∧ dist y z < ε

tactic: rw [← div_lt_one (add_pos hε hδ)] at h
state_before: 𝕜 : Type ?u.213757
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y✝ z : E
δ ε : ℝ
hδ : 0 < δ
hε : 0 < ε
h : dist x z < ε + δ
y : E
hy : dist x y = δ / (ε + δ) * dist x z ∧ dist y z = ε / (ε + δ) * dist x z
⊢ dist x z / (ε + δ) * δ < δ ∧ dist x z / (ε + δ) * ε < ε

tactic: exact ⟨mul_lt_of_lt_one_left hδ h, mul_lt_of_lt_one_left hε h⟩
state_before: 𝕜 : Type ?u.213757
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y✝ z : E
δ ε : ℝ
hδ : 0 < δ
hε : 0 < ε
h : dist x z / (ε + δ) < 1
y : E
hy : dist x y = δ / (ε + δ) * dist x z ∧ dist y z = ε / (ε + δ) * dist x z
⊢ dist x z / (ε + δ) * δ < δ ∧ dist x z / (ε + δ) * ε < ε

tactic: rw [← add_div, div_self (add_pos hε hδ).ne']
state_before: 𝕜 : Type ?u.213757
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hδ : 0 < δ
hε : 0 < ε
h : dist x z < ε + δ
⊢ ε / (ε + δ) + δ / (ε + δ) = 1
Theorem: Combinatorics.Line.diagonal_apply
File: Mathlib/Combinatorics/HalesJewett.lean

tactic: simp_rw [Line.diagonal, Option.getD_none]
state_before: α : Type u_1
ι : Type u_2
inst✝ : Nonempty ι
x : α
⊢ (fun x i => Option.getD (idxFun (diagonal α ι) i) x) x = fun x_1 => x
Theorem: DiscreteQuotient.map_ofLE
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: rcases c with ⟨⟩
state_before: α : Type ?u.34804
X : Type u_1
Y : Type u_2
Z : Type ?u.34813
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
f : C(X, Y)
A A' : DiscreteQuotient X
B B' : DiscreteQuotient Y
g : C(Y, Z)
C : DiscreteQuotient Z
cond : LEComap f A B
h : A' ≤ A
c : Quotient A'.toSetoid
⊢ map f cond (ofLE h c) = map f (_ : LEComap f A' B) c

tactic: rfl
state_before: case mk
α : Type ?u.34804
X : Type u_1
Y : Type u_2
Z : Type ?u.34813
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
f : C(X, Y)
A A' : DiscreteQuotient X
B B' : DiscreteQuotient Y
g : C(Y, Z)
C : DiscreteQuotient Z
cond : LEComap f A B
h : A' ≤ A
c : Quotient A'.toSetoid
a✝ : X
⊢ map f cond (ofLE h (Quot.mk Setoid.r a✝)) = map f (_ : LEComap f A' B) (Quot.mk Setoid.r a✝)
Theorem: IsExposed.inter_right
File: Mathlib/Analysis/Convex/Exposed.lean

tactic: rw [inter_comm]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 B C
hCA : C ⊆ A
⊢ IsExposed 𝕜 (A ∩ B) C

tactic: exact hC.inter_left hCA
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 B C
hCA : C ⊆ A
⊢ IsExposed 𝕜 (B ∩ A) C
Theorem: Finsupp.single_multiset_sum
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: rw [Multiset.sum_cons, single_add, ih, Multiset.map_cons, Multiset.sum_cons]
state_before: α : Type u_2
ι : Type ?u.265760
γ : Type ?u.265763
A : Type ?u.265766
B : Type ?u.265769
C : Type ?u.265772
inst✝³ : AddCommMonoid A
inst✝² : AddCommMonoid B
inst✝¹ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝¹ : Finset α
f : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.268902
M : Type u_1
M' : Type ?u.268908
N : Type ?u.268911
P : Type ?u.268914
G : Type ?u.268917
H : Type ?u.268920
R : Type ?u.268923
S : Type ?u.268926
inst✝ : AddCommMonoid M
s✝ : Multiset M
a✝ : α
a : M
s : Multiset M
ih : single a✝ (Multiset.sum s) = Multiset.sum (Multiset.map (single a✝) s)
⊢ single a✝ (Multiset.sum (a ::ₘ s)) = Multiset.sum (Multiset.map (single a✝) (a ::ₘ s))
Theorem: ENNReal.tsum_geometric
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: cases' lt_or_le r 1 with hr hr
state_before: α : Type ?u.250475
β : Type ?u.250478
ι : Type ?u.250481
r : ℝ≥0∞
⊢ (∑' (n : ℕ), r ^ n) = (1 - r)⁻¹

tactic: rcases ENNReal.lt_iff_exists_coe.1 hr with ⟨r, rfl, hr'⟩
state_before: case inl
α : Type ?u.250475
β : Type ?u.250478
ι : Type ?u.250481
r : ℝ≥0∞
hr : r < 1
⊢ (∑' (n : ℕ), r ^ n) = (1 - r)⁻¹

tactic: norm_cast at *
state_before: case inl.intro.intro
α : Type ?u.250475
β : Type ?u.250478
ι : Type ?u.250481
r : ℝ≥0
hr' : ↑r < 1
hr : ↑r < 1
⊢ (∑' (n : ℕ), ↑r ^ n) = (1 - ↑r)⁻¹

tactic: convert ENNReal.tsum_coe_eq (NNReal.hasSum_geometric hr)
state_before: case inl.intro.intro
α : Type ?u.250475
β : Type ?u.250478
ι : Type ?u.250481
r : ℝ≥0
hr' hr : r < 1
⊢ (∑' (n : ℕ), ↑(r ^ n)) = (1 - ↑r)⁻¹

tactic: rw [ENNReal.coe_inv <| ne_of_gt <| tsub_pos_iff_lt.2 hr, coe_sub, coe_one]
state_before: case h.e'_3
α : Type ?u.250475
β : Type ?u.250478
ι : Type ?u.250481
r : ℝ≥0
hr' hr : r < 1
⊢ (1 - ↑r)⁻¹ = ↑(1 - r)⁻¹

tactic: rw [tsub_eq_zero_iff_le.mpr hr, ENNReal.inv_zero, ENNReal.tsum_eq_iSup_nat, iSup_eq_top]
state_before: case inr
α : Type ?u.250475
β : Type ?u.250478
ι : Type ?u.250481
r : ℝ≥0∞
hr : 1 ≤ r
⊢ (∑' (n : ℕ), r ^ n) = (1 - r)⁻¹

tactic: refine' fun a ha =>
  (ENNReal.exists_nat_gt (lt_top_iff_ne_top.1 ha)).imp fun n hn => lt_of_lt_of_le hn _
state_before: case inr
α : Type ?u.250475
β : Type ?u.250478
ι : Type ?u.250481
r : ℝ≥0∞
hr : 1 ≤ r
⊢ ∀ (b : ℝ≥0∞), b < ⊤ → ∃ i, b < ∑ a in Finset.range i, r ^ a

tactic: calc
  (n : ℝ≥0∞) = ∑ i in range n, 1 := by rw [sum_const, nsmul_one, card_range]
  _ ≤ ∑ i in range n, r ^ i := by gcongr; apply one_le_pow_of_one_le' hr
state_before: case inr
α : Type ?u.250475
β : Type ?u.250478
ι : Type ?u.250481
r : ℝ≥0∞
hr : 1 ≤ r
a : ℝ≥0∞
ha : a < ⊤
n : ℕ
hn : a < ↑n
⊢ ↑n ≤ ∑ a in Finset.range n, r ^ a

tactic: rw [sum_const, nsmul_one, card_range]
state_before: α : Type ?u.250475
β : Type ?u.250478
ι : Type ?u.250481
r : ℝ≥0∞
hr : 1 ≤ r
a : ℝ≥0∞
ha : a < ⊤
n : ℕ
hn : a < ↑n
⊢ ↑n = ∑ i in Finset.range n, 1

tactic: gcongr
state_before: α : Type ?u.250475
β : Type ?u.250478
ι : Type ?u.250481
r : ℝ≥0∞
hr : 1 ≤ r
a : ℝ≥0∞
ha : a < ⊤
n : ℕ
hn : a < ↑n
⊢ ∑ i in Finset.range n, 1 ≤ ∑ i in Finset.range n, r ^ i

tactic: apply one_le_pow_of_one_le' hr
state_before: case h
α : Type ?u.250475
β : Type ?u.250478
ι : Type ?u.250481
r : ℝ≥0∞
hr : 1 ≤ r
a : ℝ≥0∞
ha : a < ⊤
n : ℕ
hn : a < ↑n
i✝ : ℕ
a✝ : i✝ ∈ Finset.range n
⊢ 1 ≤ r ^ i✝
Theorem: Matrix.det_of_lowerTriangular
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: rw [← det_transpose]
state_before: α : Type ?u.123418
β : Type ?u.123421
m : Type u_1
n : Type ?u.123427
o : Type ?u.123430
m' : α → Type ?u.123435
n' : α → Type ?u.123440
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : LinearOrder m
M : Matrix m m R
h : BlockTriangular M ↑toDual
⊢ det M = ∏ i : m, M i i

tactic: exact det_of_upperTriangular h.transpose
state_before: α : Type ?u.123418
β : Type ?u.123421
m : Type u_1
n : Type ?u.123427
o : Type ?u.123430
m' : α → Type ?u.123435
n' : α → Type ?u.123440
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : LinearOrder m
M : Matrix m m R
h : BlockTriangular M ↑toDual
⊢ det Mᵀ = ∏ i : m, M i i
Theorem: Con.lift_range
File: Mathlib/GroupTheory/Congruence.lean

tactic: rintro ⟨⟨y⟩, hy⟩
state_before: M : Type u_1
N : Type ?u.64638
P : Type u_2
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x✝ y : M
f : M →* P
H : c ≤ ker f
x : P
⊢ x ∈ MonoidHom.mrange (lift c f H) → x ∈ MonoidHom.mrange f

tactic: exact ⟨y, hy⟩
state_before: case intro.mk
M : Type u_1
N : Type ?u.64638
P : Type u_2
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x✝ y✝ : M
f : M →* P
H : c ≤ ker f
x : P
w✝ : Con.Quotient c
y : M
hy : ↑(lift c f H) (Quot.mk r y) = x
⊢ x ∈ MonoidHom.mrange f
Theorem: Submodule.orthogonal_disjoint
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: simp [disjoint_iff, K.inf_orthogonal_eq_bot]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.40489
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ Disjoint K Kᗮ
Theorem: exists_polynomial_near_of_continuousOn
File: Mathlib/Topology/ContinuousFunction/Weierstrass.lean

tactic: let f' : C(Set.Icc a b, ℝ) := ⟨fun x => f x, continuousOn_iff_continuous_restrict.mp c⟩
state_before: a b : ℝ
f : ℝ → ℝ
c : ContinuousOn f (Set.Icc a b)
ε : ℝ
pos : 0 < ε
⊢ ∃ p, ∀ (x : ℝ), x ∈ Set.Icc a b → Abs.abs (Polynomial.eval x p - f x) < ε

tactic: obtain ⟨p, b⟩ := exists_polynomial_near_continuousMap a b f' ε pos
state_before: a b : ℝ
f : ℝ → ℝ
c : ContinuousOn f (Set.Icc a b)
ε : ℝ
pos : 0 < ε
f' : C(↑(Set.Icc a b), ℝ) := ContinuousMap.mk fun x => f ↑x
⊢ ∃ p, ∀ (x : ℝ), x ∈ Set.Icc a b → Abs.abs (Polynomial.eval x p - f x) < ε

tactic: use p
state_before: case intro
a b✝ : ℝ
f : ℝ → ℝ
c : ContinuousOn f (Set.Icc a b✝)
ε : ℝ
pos : 0 < ε
f' : C(↑(Set.Icc a b✝), ℝ) := ContinuousMap.mk fun x => f ↑x
p : ℝ[X]
b : ‖Polynomial.toContinuousMapOn p (Set.Icc a b✝) - f'‖ < ε
⊢ ∃ p, ∀ (x : ℝ), x ∈ Set.Icc a b✝ → Abs.abs (Polynomial.eval x p - f x) < ε

tactic: rw [norm_lt_iff _ pos] at b
state_before: case intro
a b✝ : ℝ
f : ℝ → ℝ
c : ContinuousOn f (Set.Icc a b✝)
ε : ℝ
pos : 0 < ε
f' : C(↑(Set.Icc a b✝), ℝ) := ContinuousMap.mk fun x => f ↑x
p : ℝ[X]
b : ‖Polynomial.toContinuousMapOn p (Set.Icc a b✝) - f'‖ < ε
⊢ ∀ (x : ℝ), x ∈ Set.Icc a b✝ → Abs.abs (Polynomial.eval x p - f x) < ε

tactic: intro x m
state_before: case intro
a b✝ : ℝ
f : ℝ → ℝ
c : ContinuousOn f (Set.Icc a b✝)
ε : ℝ
pos : 0 < ε
f' : C(↑(Set.Icc a b✝), ℝ) := ContinuousMap.mk fun x => f ↑x
p : ℝ[X]
b : ∀ (x : ↑(Set.Icc a b✝)), ‖↑(Polynomial.toContinuousMapOn p (Set.Icc a b✝) - f') x‖ < ε
⊢ ∀ (x : ℝ), x ∈ Set.Icc a b✝ → Abs.abs (Polynomial.eval x p - f x) < ε

tactic: exact b ⟨x, m⟩
state_before: case intro
a b✝ : ℝ
f : ℝ → ℝ
c : ContinuousOn f (Set.Icc a b✝)
ε : ℝ
pos : 0 < ε
f' : C(↑(Set.Icc a b✝), ℝ) := ContinuousMap.mk fun x => f ↑x
p : ℝ[X]
b : ∀ (x : ↑(Set.Icc a b✝)), ‖↑(Polynomial.toContinuousMapOn p (Set.Icc a b✝) - f') x‖ < ε
x : ℝ
m : x ∈ Set.Icc a b✝
⊢ Abs.abs (Polynomial.eval x p - f x) < ε
Theorem: Function.extend_mul
File: Mathlib/Data/Pi/Algebra.lean

tactic: classical
funext x
simp only [not_exists, extend_def, Pi.mul_apply, apply_dite₂, dite_eq_ite, ite_self]
state_before: I : Type u
α : Type u_3
β : Type u_2
γ : Type u_1
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f✝ i
i : I
inst✝ : Mul γ
f : α → β
g₁ g₂ : α → γ
e₁ e₂ : β → γ
⊢ extend f (g₁ * g₂) (e₁ * e₂) = extend f g₁ e₁ * extend f g₂ e₂

tactic: funext x
state_before: I : Type u
α : Type u_3
β : Type u_2
γ : Type u_1
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f✝ i
i : I
inst✝ : Mul γ
f : α → β
g₁ g₂ : α → γ
e₁ e₂ : β → γ
⊢ extend f (g₁ * g₂) (e₁ * e₂) = extend f g₁ e₁ * extend f g₂ e₂

tactic: simp only [not_exists, extend_def, Pi.mul_apply, apply_dite₂, dite_eq_ite, ite_self]
state_before: case h
I : Type u
α : Type u_3
β : Type u_2
γ : Type u_1
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f✝ i
i : I
inst✝ : Mul γ
f : α → β
g₁ g₂ : α → γ
e₁ e₂ : β → γ
x : β
⊢ extend f (g₁ * g₂) (e₁ * e₂) x = (extend f g₁ e₁ * extend f g₂ e₂) x
Theorem: eqOn_closure₂'
File: Mathlib/Topology/Separation.lean

tactic: simpa only [subset_def, mem_iInter]
state_before: α : Type u
β : Type v
inst✝³ : TopologicalSpace α
γ : Type u_1
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space α
s : Set β
t : Set γ
f g : β → γ → α
h : ∀ (x : β), x ∈ s → ∀ (y : γ), y ∈ t → f x y = g x y
hf₁ : ∀ (x : β), Continuous (f x)
hf₂ : ∀ (y : γ), Continuous fun x => f x y
hg₁ : ∀ (x : β), Continuous (g x)
hg₂ : ∀ (y : γ), Continuous fun x => g x y
this : closure s ⊆ ⋂ (y : γ) (_ : y ∈ closure t), {x | f x y = g x y}
⊢ ∀ (x : β), x ∈ closure s → ∀ (y : γ), y ∈ closure t → f x y = g x y
Theorem: Subsemigroup.nonUnitalSubsemiringClosure_eq_closure
File: Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean

tactic: ext
state_before: R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
⊢ nonUnitalSubsemiringClosure M = NonUnitalSubsemiring.closure ↑M

tactic: refine ⟨fun hx => ?_,
  fun hx => (NonUnitalSubsemiring.mem_closure.mp hx) M.nonUnitalSubsemiringClosure fun s sM => ?_⟩
<;> rintro - ⟨H1, rfl⟩
<;> rintro - ⟨H2, rfl⟩
state_before: case h
R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
x✝ : R
⊢ x✝ ∈ nonUnitalSubsemiringClosure M ↔ x✝ ∈ NonUnitalSubsemiring.closure ↑M

tactic: exact AddSubmonoid.mem_closure.mp hx H1.toAddSubmonoid H2
state_before: case h.refine_1.intro.intro
R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
x✝ : R
hx : x✝ ∈ nonUnitalSubsemiringClosure M
H1 : NonUnitalSubsemiring R
H2 : H1 ∈ {S | ↑M ⊆ ↑S}
⊢ x✝ ∈ (fun h => ↑H1) H2

tactic: exact H2 sM
state_before: case h.refine_2.intro.intro
R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
x✝ : R
hx : x✝ ∈ NonUnitalSubsemiring.closure ↑M
s : R
sM : s ∈ ↑M
H1 : AddSubmonoid R
H2 : H1 ∈ {S | ↑M ⊆ ↑S}
⊢ s ∈ (fun h => ↑H1) H2
Theorem: Set.iUnion_Icc_right
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: simp only [← Ici_inter_Iic, ← inter_iUnion, iUnion_Iic, inter_univ]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : Preorder α
a✝ b c a : α
⊢ (⋃ (b : α), Icc a b) = Ici a
Theorem: List.permutations_nil
File: Mathlib/Data/List/Permutation.lean

tactic: rw [permutations, permutationsAux_nil]
state_before: α : Type u_1
β : Type ?u.27175
⊢ permutations [] = [[]]
Theorem: CategoryTheory.unitCompPartialBijectiveAux_symm_apply
File: Mathlib/CategoryTheory/Adjunction/Reflective.lean

tactic: simp [unitCompPartialBijectiveAux]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
i : D ⥤ C
inst✝ : Reflective i
A : C
B : D
f : i.obj ((leftAdjoint i).obj A) ⟶ i.obj B
⊢ ↑(unitCompPartialBijectiveAux A B).symm f = (ofRightAdjoint i).unit.app A ≫ f
Theorem: Set.PartiallyWellOrderedOn.union
File: Mathlib/Order/WellFoundedSet.lean

tactic: rintro f hf
state_before: ι : Type ?u.44198
α : Type u_1
β : Type ?u.44204
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
hs : PartiallyWellOrderedOn s r
ht : PartiallyWellOrderedOn t r
⊢ PartiallyWellOrderedOn (s ∪ t) r

tactic: rcases Nat.exists_subseq_of_forall_mem_union f hf with ⟨g, hgs | hgt⟩
state_before: ι : Type ?u.44198
α : Type u_1
β : Type ?u.44204
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
hs : PartiallyWellOrderedOn s r
ht : PartiallyWellOrderedOn t r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s ∪ t
⊢ ∃ m n, m < n ∧ r (f m) (f n)

tactic: rcases hs _ hgs with ⟨m, n, hlt, hr⟩
state_before: case intro.inl
ι : Type ?u.44198
α : Type u_1
β : Type ?u.44204
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
hs : PartiallyWellOrderedOn s r
ht : PartiallyWellOrderedOn t r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s ∪ t
g : ℕ ↪o ℕ
hgs : ∀ (n : ℕ), f (↑g n) ∈ s
⊢ ∃ m n, m < n ∧ r (f m) (f n)

tactic: exact ⟨g m, g n, g.strictMono hlt, hr⟩
state_before: case intro.inl.intro.intro.intro
ι : Type ?u.44198
α : Type u_1
β : Type ?u.44204
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
hs : PartiallyWellOrderedOn s r
ht : PartiallyWellOrderedOn t r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s ∪ t
g : ℕ ↪o ℕ
hgs : ∀ (n : ℕ), f (↑g n) ∈ s
m n : ℕ
hlt : m < n
hr : r (f (↑g m)) (f (↑g n))
⊢ ∃ m n, m < n ∧ r (f m) (f n)

tactic: rcases ht _ hgt with ⟨m, n, hlt, hr⟩
state_before: case intro.inr
ι : Type ?u.44198
α : Type u_1
β : Type ?u.44204
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
hs : PartiallyWellOrderedOn s r
ht : PartiallyWellOrderedOn t r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s ∪ t
g : ℕ ↪o ℕ
hgt : ∀ (n : ℕ), f (↑g n) ∈ t
⊢ ∃ m n, m < n ∧ r (f m) (f n)

tactic: exact ⟨g m, g n, g.strictMono hlt, hr⟩
state_before: case intro.inr.intro.intro.intro
ι : Type ?u.44198
α : Type u_1
β : Type ?u.44204
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
hs : PartiallyWellOrderedOn s r
ht : PartiallyWellOrderedOn t r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s ∪ t
g : ℕ ↪o ℕ
hgt : ∀ (n : ℕ), f (↑g n) ∈ t
m n : ℕ
hlt : m < n
hr : r (f (↑g m)) (f (↑g n))
⊢ ∃ m n, m < n ∧ r (f m) (f n)
Theorem: Filter.ofSets_filter_eq_generate
File: Mathlib/Order/Filter/Bases.lean

tactic: rw [← (FilterBasis.ofSets s).generate, FilterBasis.ofSets_sets, ← generate_eq_generate_inter]
state_before: α : Type u_1
β : Type ?u.15898
γ : Type ?u.15901
ι : Sort ?u.15904
ι' : Sort ?u.15907
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : Set (Set α)
⊢ FilterBasis.filter (FilterBasis.ofSets s) = generate s
Theorem: Finset.insert_idem
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_insert, ←or_assoc, or_self_iff]
state_before: α : Type u_1
β : Type ?u.110948
γ : Type ?u.110951
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
x : α
⊢ x ∈ insert a (insert a s) ↔ x ∈ insert a s
Theorem: mem_reesAlgebra_iff_support
File: Mathlib/RingTheory/ReesAlgebra.lean

tactic: apply forall_congr'
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
f : R[X]
⊢ f ∈ reesAlgebra I ↔ ∀ (i : ℕ), i ∈ support f → coeff f i ∈ I ^ i

tactic: intro a
state_before: case h
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
f : R[X]
⊢ ∀ (a : ℕ), coeff f a ∈ I ^ a ↔ a ∈ support f → coeff f a ∈ I ^ a

tactic: rw [mem_support_iff, Iff.comm, imp_iff_right_iff, Ne.def, ← imp_iff_not_or]
state_before: case h
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
f : R[X]
a : ℕ
⊢ coeff f a ∈ I ^ a ↔ a ∈ support f → coeff f a ∈ I ^ a

tactic: exact fun e => e.symm ▸ (I ^ a).zero_mem
state_before: case h
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
f : R[X]
a : ℕ
⊢ coeff f a = 0 → coeff f a ∈ I ^ a
Theorem: Acc.rank_lt_of_rel
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [hb.rank_eq]
state_before: α : Type u
r : α → α → Prop
a b : α
hb : Acc r b
h : r a b
⊢ succ (rank (_ : Acc r a)) ≤ rank hb

tactic: refine' le_trans _ (Ordinal.le_sup _ ⟨a, h⟩)
state_before: α : Type u
r : α → α → Prop
a b : α
hb : Acc r b
h : r a b
⊢ succ (rank (_ : Acc r a)) ≤ sup fun b_1 => succ (rank (_ : Acc r ↑b_1))

tactic: rfl
state_before: α : Type u
r : α → α → Prop
a b : α
hb : Acc r b
h : r a b
⊢ succ (rank (_ : Acc r a)) ≤ succ (rank (_ : Acc r ↑{ val := a, property := h }))
Theorem: skewAdjointLieSubalgebraEquiv_apply
File: Mathlib/Algebra/Lie/SkewAdjoint.lean

tactic: simp [skewAdjointLieSubalgebraEquiv]
state_before: R : Type u
M : Type v
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
B : BilinForm R M
N : Type w
inst✝¹ : AddCommGroup N
inst✝ : Module R N
e : N ≃ₗ[R] M
f : { x // x ∈ skewAdjointLieSubalgebra (comp B ↑e ↑e) }
⊢ ↑(↑(skewAdjointLieSubalgebraEquiv B e) f) = ↑(LinearEquiv.lieConj e) ↑f
Theorem: Set.range_list_getD
File: Mathlib/Data/Set/List.lean

tactic: simp only [range_list_get?, image_insert_eq, Option.getD, image_image, image_id']
state_before: α : Type u_1
β : Type ?u.2053
l : List α
d : α
⊢ (fun o => Option.getD o d) '' range (get? l) = insert d {x | x ∈ l}
Theorem: Set.preimage_const_mul_Ioc_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simpa only [mul_comm] using preimage_mul_const_Ioc_of_neg a b h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : c < 0
⊢ (fun x x_1 => x * x_1) c ⁻¹' Ioc a b = Ico (b / c) (a / c)
Theorem: Real.tendsto_tan_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: convert tendsto_cos_pi_div_two.inv_tendsto_zero.atTop_mul zero_lt_one tendsto_sin_pi_div_two
  using 1
state_before: ⊢ Tendsto tan (𝓝[Iio (π / 2)] (π / 2)) atTop

tactic: simp only [Pi.inv_apply, ← div_eq_inv_mul, ← tan_eq_sin_div_cos]
state_before: case h.e'_3

⊢ tan = fun x => cos⁻¹ x * sin x
Theorem: SetLike.pow_mem_graded
File: Mathlib/Algebra/GradedMonoid.lean

tactic: match n with
| 0 =>
  rw [pow_zero, zero_nsmul]
  exact one_mem_graded _
| n+1 =>
  rw [pow_succ', succ_nsmul']
  exact mul_mem_graded (pow_mem_graded n h) h
state_before: ι : Type u_3
R : Type u_1
S : Type u_2
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
r : R
i : ι
h : r ∈ A i
⊢ r ^ n ∈ A (n • i)

tactic: rw [pow_zero, zero_nsmul]
state_before: ι : Type u_3
R : Type u_1
S : Type u_2
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
r : R
i : ι
h : r ∈ A i
⊢ r ^ 0 ∈ A (0 • i)

tactic: exact one_mem_graded _
state_before: ι : Type u_3
R : Type u_1
S : Type u_2
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
r : R
i : ι
h : r ∈ A i
⊢ 1 ∈ A 0

tactic: rw [pow_succ', succ_nsmul']
state_before: ι : Type u_3
R : Type u_1
S : Type u_2
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n✝ : ℕ
r : R
i : ι
h : r ∈ A i
n : ℕ
⊢ r ^ (n + 1) ∈ A ((n + 1) • i)

tactic: exact mul_mem_graded (pow_mem_graded n h) h
state_before: ι : Type u_3
R : Type u_1
S : Type u_2
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n✝ : ℕ
r : R
i : ι
h : r ∈ A i
n : ℕ
⊢ r ^ n * r ∈ A (n • i + i)
Theorem: Commute.inv
File: Mathlib/Algebra/Group/Commute.lean

tactic: rw [hab.eq, mul_inv_rev]
state_before: G : Type u_1
inst✝ : DivisionMonoid G
a b c d : G
hab : Commute a b
⊢ (a * b)⁻¹ = a⁻¹ * b⁻¹
Theorem: Turing.Tape.write_self
File: Mathlib/Computability/TuringMachine.lean

tactic: rintro ⟨⟩
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
⊢ ∀ (T : Tape Γ), write T.head T = T

tactic: rfl
state_before: case mk
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ write { head := head✝, left := left✝, right := right✝ }.head { head := head✝, left := left✝, right := right✝ } =
    { head := head✝, left := left✝, right := right✝ }
Theorem: Stream'.WSeq.mem_cons_iff
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [ret_mem]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
b a : α
⊢ some (b, s) ∈ destruct (cons b s)
Theorem: Dfinsupp.single_eq_of_sigma_eq
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: cases h
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i j : ι
xi : β i
xj : β j
h : { fst := i, snd := xi } = { fst := j, snd := xj }
⊢ single i xi = single j xj

tactic: rfl
state_before: case refl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ i : ι
xi : β i
⊢ single i xi = single i xi