tasksource/leandojo huggingface dataset:
Theorem: Pmf.support_pure
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: simp [mem_support_iff]
state_before: α : Type u_1
β : Type ?u.1517
γ : Type ?u.1520
a a'✝ a' : α
⊢ a' ∈ support (pure a) ↔ a' ∈ {a}
Theorem: Array.pop_push
File: Std/Data/Array/Lemmas.lean

tactic: simp [pop]
state_before: α : Type u_1
x : α
a : Array α
⊢ pop (push a x) = a
Theorem: Rat.mul_self_num
File: Mathlib/Data/Rat/Lemmas.lean

tactic: rw [mul_num, Int.natAbs_mul, Nat.coprime.gcd_eq_one, Int.ofNat_one, Int.ediv_one]
state_before: q : ℚ
⊢ (q * q).num = q.num * q.num

tactic: exact (q.reduced.mul_right q.reduced).mul (q.reduced.mul_right q.reduced)
state_before: q : ℚ
⊢ Nat.coprime (Int.natAbs q.num * Int.natAbs q.num) (q.den * q.den)
Theorem: Associated.symm
File: Mathlib/Algebra/Associated.lean

tactic: rw [mul_assoc, Units.mul_inv, mul_one]
state_before: α : Type u_1
β : Type ?u.145603
γ : Type ?u.145606
δ : Type ?u.145609
inst✝ : Monoid α
x : α
u : αˣ
⊢ x * ↑u * ↑u⁻¹ = x
Theorem: PowerSeries.monomial_eq_mk
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff_monomial, coeff_mk]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
a : R
m : ℕ
⊢ ↑(coeff R m) (↑(monomial R n) a) = ↑(coeff R m) (mk fun m => if m = n then a else 0)
Theorem: MvPowerSeries.coeff_zero_X_mul
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [← (φ.commute_X s).eq, coeff_zero_mul_X]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
φ : MvPowerSeries σ R
s : σ
⊢ ↑(coeff R 0) (X s * φ) = 0
Theorem: Complex.lim_eq_lim_im_add_lim_re
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [limAux, cauSeqRe, ofReal']
state_before: f : CauSeq ℂ ↑abs
x✝ : ℕ
⊢ (↑(CauSeq.const (↑abs) (limAux f)) x✝).re =
    (↑(CauSeq.const (↑abs) (↑(CauSeq.lim (cauSeqRe f)) + ↑(CauSeq.lim (cauSeqIm f)) * I)) x✝).re

tactic: simp [limAux, cauSeqIm, ofReal']
state_before: f : CauSeq ℂ ↑abs
x✝ : ℕ
⊢ (↑(CauSeq.const (↑abs) (limAux f)) x✝).im =
    (↑(CauSeq.const (↑abs) (↑(CauSeq.lim (cauSeqRe f)) + ↑(CauSeq.lim (cauSeqIm f)) * I)) x✝).im
Theorem: Set.image2_union_inter_subset_union
File: Mathlib/Data/Set/NAry.lean

tactic: rw [image2_union_left]
state_before: α : Type u_2
α' : Type ?u.50181
β : Type u_3
β' : Type ?u.50187
γ : Type u_1
γ' : Type ?u.50193
δ : Type ?u.50196
δ' : Type ?u.50199
ε : Type ?u.50202
ε' : Type ?u.50205
ζ : Type ?u.50208
ζ' : Type ?u.50211
ν : Type ?u.50214
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_left <| inter_subset_left _ _)
    (image2_subset_left <| inter_subset_right _ _)
state_before: α : Type u_2
α' : Type ?u.50181
β : Type u_3
β' : Type ?u.50187
γ : Type u_1
γ' : Type ?u.50193
δ : Type ?u.50196
δ' : Type ?u.50199
ε : Type ?u.50202
ε' : Type ?u.50205
ζ : Type ?u.50208
ζ' : Type ?u.50211
ν : Type ?u.50214
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 (t ∩ t') ∪ image2 f s' (t ∩ t') ⊆ image2 f s t ∪ image2 f s' t'
Theorem: Turing.PartrecToTM2.supports_insert
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [Supports]
state_before: K S : Finset Λ'
q : Λ'
⊢ Supports (insert q K) S ↔ TM2.SupportsStmt S (tr q) ∧ Supports K S
Theorem: tendsto_comp_coe_Iio_atTop
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [← map_coe_Iio_atTop, tendsto_map'_iff]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto f (𝓝[Iio a] a) l

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto (f ∘ Subtype.val) atTop l
Theorem: CategoryTheory.Limits.biprod.lift_mapBiprod
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean

tactic: rw [← biprod.map_lift_mapBiprod, Category.assoc, Iso.hom_inv_id, Category.comp_id]
state_before: C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
F : C ⥤ D
inst✝² : PreservesZeroMorphisms F
X Y : C
inst✝¹ : HasBinaryBiproduct X Y
inst✝ : PreservesBinaryBiproduct X Y F
W : C
f : W ⟶ X
g : W ⟶ Y
⊢ lift (F.map f) (F.map g) ≫ (mapBiprod F X Y).inv = F.map (lift f g)
Theorem: Real.rpow_nat_inv_pow_nat
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: have hn0 : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.2 hn
state_before: x✝ y z x : ℝ
hx : 0 ≤ x
n : ℕ
hn : n ≠ 0
⊢ (x ^ (↑n)⁻¹) ^ n = x

tactic: rw [← rpow_nat_cast, ← rpow_mul hx, inv_mul_cancel hn0, rpow_one]
state_before: x✝ y z x : ℝ
hx : 0 ≤ x
n : ℕ
hn : n ≠ 0
hn0 : ↑n ≠ 0
⊢ (x ^ (↑n)⁻¹) ^ n = x
Theorem: QuadraticForm.polar_neg
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: simp only [polar, Pi.neg_apply, sub_eq_add_neg, neg_add]
state_before: S : Type ?u.2804
R : Type u_1
R₁ : Type ?u.2810
M : Type u_2
inst✝² : Ring R
inst✝¹ : CommRing R₁
inst✝ : AddCommGroup M
f : M → R
x y : M
⊢ polar (-f) x y = -polar f x y
Theorem: AList.lookupFinsupp_eq_iff_of_ne_zero
File: Mathlib/Data/Finsupp/AList.lean

tactic: rw [lookupFinsupp_apply]
state_before: α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
x : M
hx : x ≠ 0
⊢ ↑(lookupFinsupp l) a = x ↔ x ∈ lookup a l

tactic: cases' lookup a l with m <;> simp [hx.symm]
state_before: α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
l : AList fun _x => M
a : α
x : M
hx : x ≠ 0
⊢ Option.getD (lookup a l) 0 = x ↔ x ∈ lookup a l
Theorem: DFA.toNFA_correct
File: Mathlib/Computability/NFA.lean

tactic: ext x
state_before: α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
⊢ NFA.accepts (toNFA M) = accepts M

tactic: rw [NFA.mem_accepts, toNFA_start, toNFA_evalFrom_match]
state_before: case h
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
x : List α
⊢ x ∈ NFA.accepts (toNFA M) ↔ x ∈ accepts M

tactic: constructor
state_before: case h
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
x : List α
⊢ (∃ S, S ∈ (toNFA M).accept ∧ S ∈ {evalFrom M M.start x}) ↔ x ∈ accepts M

tactic: rintro ⟨S, hS₁, hS₂⟩
state_before: case h.mp
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
x : List α
⊢ (∃ S, S ∈ (toNFA M).accept ∧ S ∈ {evalFrom M M.start x}) → x ∈ accepts M

tactic: rwa [Set.mem_singleton_iff.mp hS₂] at hS₁
state_before: case h.mp.intro.intro
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
x : List α
S : σ
hS₁ : S ∈ (toNFA M).accept
hS₂ : S ∈ {evalFrom M M.start x}
⊢ x ∈ accepts M

tactic: exact fun h => ⟨M.eval x, h, rfl⟩
state_before: case h.mpr
α : Type u
σ σ' : Type v
M✝ : NFA α σ
M : DFA α σ
x : List α
⊢ x ∈ accepts M → ∃ S, S ∈ (toNFA M).accept ∧ S ∈ {evalFrom M M.start x}
Theorem: Finsupp.prod_add_index'
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: classical exact prod_add_index (fun a _ => h_zero a) fun a _ => h_add a
state_before: α : Type u_3
ι : Type ?u.341371
γ : Type ?u.341374
A : Type ?u.341377
B : Type ?u.341380
C : Type ?u.341383
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.344513
M : Type u_1
M' : Type ?u.344519
N : Type u_2
P : Type ?u.344525
G : Type ?u.344528
H : Type ?u.344531
R : Type ?u.344534
S : Type ?u.344537
inst✝¹ : AddZeroClass M
inst✝ : CommMonoid N
f g : α →₀ M
h : α → M → N
h_zero : ∀ (a : α), h a 0 = 1
h_add : ∀ (a : α) (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ * h a b₂
⊢ prod (f + g) h = prod f h * prod g h

tactic: exact prod_add_index (fun a _ => h_zero a) fun a _ => h_add a
state_before: α : Type u_3
ι : Type ?u.341371
γ : Type ?u.341374
A : Type ?u.341377
B : Type ?u.341380
C : Type ?u.341383
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.344513
M : Type u_1
M' : Type ?u.344519
N : Type u_2
P : Type ?u.344525
G : Type ?u.344528
H : Type ?u.344531
R : Type ?u.344534
S : Type ?u.344537
inst✝¹ : AddZeroClass M
inst✝ : CommMonoid N
f g : α →₀ M
h : α → M → N
h_zero : ∀ (a : α), h a 0 = 1
h_add : ∀ (a : α) (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ * h a b₂
⊢ prod (f + g) h = prod f h * prod g h
Theorem: CategoryTheory.IsPushout.of_map_of_faithful
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: simpa only [F.map_comp] using H.w
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝¹ : ReflectsColimit (span f g) F
inst✝ : Faithful F
H : IsPushout (F.map f) (F.map g) (F.map h) (F.map i)
⊢ F.map (f ≫ h) = F.map (g ≫ i)
Theorem: ENNReal.sum_lt_sum_of_nonempty
File: Mathlib/Data/Real/ENNReal.lean

tactic: induction' hs using Finset.Nonempty.cons_induction with a a s as _ IH
state_before: α : Type u_1
β : Type ?u.204885
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Finset α
hs : Finset.Nonempty s
f g : α → ℝ≥0∞
Hlt : ∀ (i : α), i ∈ s → f i < g i
⊢ ∑ i in s, f i < ∑ i in s, g i

tactic: simp [Hlt _ (Finset.mem_singleton_self _)]
state_before: case h₀
α : Type u_1
β : Type ?u.204885
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
s : Finset α
f g : α → ℝ≥0∞
Hlt✝ : ∀ (i : α), i ∈ s → f i < g i
a : α
Hlt : ∀ (i : α), i ∈ {a} → f i < g i
⊢ ∑ i in {a}, f i < ∑ i in {a}, g i

tactic: simp only [as, Finset.sum_cons, not_false_iff]
state_before: case h₁
α : Type u_1
β : Type ?u.204885
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
s✝ : Finset α
f g : α → ℝ≥0∞
Hlt✝ : ∀ (i : α), i ∈ s✝ → f i < g i
a : α
s : Finset α
as : ¬a ∈ s
hs✝ : Finset.Nonempty s
IH : (∀ (i : α), i ∈ s → f i < g i) → ∑ i in s, f i < ∑ i in s, g i
Hlt : ∀ (i : α), i ∈ cons a s as → f i < g i
⊢ ∑ i in cons a s as, f i < ∑ i in cons a s as, g i

tactic: exact
  ENNReal.add_lt_add (Hlt _ (Finset.mem_cons_self _ _))
    (IH fun i hi => Hlt _ (Finset.mem_cons.2 <| Or.inr hi))
state_before: case h₁
α : Type u_1
β : Type ?u.204885
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
s✝ : Finset α
f g : α → ℝ≥0∞
Hlt✝ : ∀ (i : α), i ∈ s✝ → f i < g i
a : α
s : Finset α
as : ¬a ∈ s
hs✝ : Finset.Nonempty s
IH : (∀ (i : α), i ∈ s → f i < g i) → ∑ i in s, f i < ∑ i in s, g i
Hlt : ∀ (i : α), i ∈ cons a s as → f i < g i
⊢ f a + ∑ i in s, f i < g a + ∑ i in s, g i
Theorem: LinearMap.IsRefl.nondegenerate_of_separatingLeft
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: refine' ⟨hB', _⟩
state_before: R : Type u_1
R₁ : Type ?u.572349
R₂ : Type ?u.572352
R₃ : Type ?u.572355
M : Type u_2
M₁ : Type ?u.572361
M₂ : Type ?u.572364
Mₗ₁ : Type ?u.572367
Mₗ₁' : Type ?u.572370
Mₗ₂ : Type ?u.572373
Mₗ₂' : Type ?u.572376
K : Type ?u.572379
K₁ : Type ?u.572382
K₂ : Type ?u.572385
V : Type ?u.572388
V₁ : Type ?u.572391
V₂ : Type ?u.572394
n : Type ?u.572397
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I I' : R →+* R
B : M →ₗ[R] M →ₗ[R] R
hB : IsRefl B
hB' : SeparatingLeft B
⊢ Nondegenerate B

tactic: rw [separatingRight_iff_flip_ker_eq_bot, hB.ker_eq_bot_iff_ker_flip_eq_bot.mp]
state_before: R : Type u_1
R₁ : Type ?u.572349
R₂ : Type ?u.572352
R₃ : Type ?u.572355
M : Type u_2
M₁ : Type ?u.572361
M₂ : Type ?u.572364
Mₗ₁ : Type ?u.572367
Mₗ₁' : Type ?u.572370
Mₗ₂ : Type ?u.572373
Mₗ₂' : Type ?u.572376
K : Type ?u.572379
K₁ : Type ?u.572382
K₂ : Type ?u.572385
V : Type ?u.572388
V₁ : Type ?u.572391
V₂ : Type ?u.572394
n : Type ?u.572397
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I I' : R →+* R
B : M →ₗ[R] M →ₗ[R] R
hB : IsRefl B
hB' : SeparatingLeft B
⊢ SeparatingRight B

tactic: rwa [← separatingLeft_iff_ker_eq_bot]
state_before: R : Type u_1
R₁ : Type ?u.572349
R₂ : Type ?u.572352
R₃ : Type ?u.572355
M : Type u_2
M₁ : Type ?u.572361
M₂ : Type ?u.572364
Mₗ₁ : Type ?u.572367
Mₗ₁' : Type ?u.572370
Mₗ₂ : Type ?u.572373
Mₗ₂' : Type ?u.572376
K : Type ?u.572379
K₁ : Type ?u.572382
K₂ : Type ?u.572385
V : Type ?u.572388
V₁ : Type ?u.572391
V₂ : Type ?u.572394
n : Type ?u.572397
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I I' : R →+* R
B : M →ₗ[R] M →ₗ[R] R
hB : IsRefl B
hB' : SeparatingLeft B
⊢ ker B = ⊥
Theorem: Polynomial.degree_X_pow_sub_C
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [sub_eq_add_neg, ← map_neg C a, degree_X_pow_add_C hn]
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Ring R
inst✝ : Nontrivial R
n : ℕ
hn : 0 < n
a : R
⊢ degree (X ^ n - ↑C a) = ↑n
Theorem: Convex.translate_preimage_right
File: Mathlib/Analysis/Convex/Basic.lean

tactic: intro x hx y hy a b ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.55832
β : Type ?u.55835
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x : E
hs : Convex 𝕜 s
z : E
⊢ Convex 𝕜 ((fun x => z + x) ⁻¹' s)

tactic: have h := hs hx hy ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.55832
β : Type ?u.55835
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x✝ : E
hs : Convex 𝕜 s
z x : E
hx : x ∈ (fun x => z + x) ⁻¹' s
y : E
hy : y ∈ (fun x => z + x) ⁻¹' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ (fun x => z + x) ⁻¹' s

tactic: rwa [smul_add, smul_add, add_add_add_comm, ← add_smul, hab, one_smul] at h
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.55832
β : Type ?u.55835
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x✝ : E
hs : Convex 𝕜 s
z x : E
hx : x ∈ (fun x => z + x) ⁻¹' s
y : E
hy : y ∈ (fun x => z + x) ⁻¹' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
h : a • (fun x => z + x) x + b • (fun x => z + x) y ∈ s
⊢ a • x + b • y ∈ (fun x => z + x) ⁻¹' s
Theorem: IsSelfAdjoint.conj_adjoint
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: rw [isSelfAdjoint_iff'] at hT⊢
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1322203
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 F
T : E →L[𝕜] E
hT : IsSelfAdjoint T
S : E →L[𝕜] F
⊢ IsSelfAdjoint (comp S (comp T (↑adjoint S)))

tactic: simp only [hT, adjoint_comp, adjoint_adjoint]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1322203
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 F
T : E →L[𝕜] E
hT : ↑adjoint T = T
S : E →L[𝕜] F
⊢ ↑adjoint (comp S (comp T (↑adjoint S))) = comp S (comp T (↑adjoint S))

tactic: exact ContinuousLinearMap.comp_assoc _ _ _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1322203
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 F
T : E →L[𝕜] E
hT : ↑adjoint T = T
S : E →L[𝕜] F
⊢ comp (comp S T) (↑adjoint S) = comp S (comp T (↑adjoint S))
Theorem: OreLocalization.universalMulHom_unique
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: ext x
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
T : Type u_2
inst✝ : Monoid T
f : R →* T
fS : { x // x ∈ S } →* Tˣ
hf : ∀ (s : { x // x ∈ S }), ↑f ↑s = ↑(↑fS s)
φ : OreLocalization R S →* T
huniv : ∀ (r : R), ↑φ (↑numeratorHom r) = ↑f r
⊢ φ = universalMulHom f fS hf

tactic: induction' x using OreLocalization.ind with r s
state_before: case h
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
T : Type u_2
inst✝ : Monoid T
f : R →* T
fS : { x // x ∈ S } →* Tˣ
hf : ∀ (s : { x // x ∈ S }), ↑f ↑s = ↑(↑fS s)
φ : OreLocalization R S →* T
huniv : ∀ (r : R), ↑φ (↑numeratorHom r) = ↑f r
x : OreLocalization R S
⊢ ↑φ x = ↑(universalMulHom f fS hf) x

tactic: rw [universalMulHom_apply, ← huniv r, numeratorHom_apply, ← mul_one (φ (r /ₒ s)), ←
  Units.val_one, ← mul_right_inv (fS s), Units.val_mul, ← mul_assoc, ← hf, ← huniv, ← φ.map_mul,
  numeratorHom_apply, OreLocalization.mul_cancel]
state_before: case h.c
R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
T : Type u_2
inst✝ : Monoid T
f : R →* T
fS : { x // x ∈ S } →* Tˣ
hf : ∀ (s : { x // x ∈ S }), ↑f ↑s = ↑(↑fS s)
φ : OreLocalization R S →* T
huniv : ∀ (r : R), ↑φ (↑numeratorHom r) = ↑f r
r : R
s : { x // x ∈ S }
⊢ ↑φ (r /ₒ s) = ↑(universalMulHom f fS hf) (r /ₒ s)
Theorem: tendsto_iff_edist_tendsto_0
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp only [EMetric.nhds_basis_eball.tendsto_right_iff, EMetric.mem_ball,
  @tendsto_order ℝ≥0∞ β _ _, forall_prop_of_false ENNReal.not_lt_zero, forall_const, true_and_iff]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.415578
inst✝ : PseudoEMetricSpace α
l : Filter β
f : β → α
y : α
⊢ Tendsto f l (𝓝 y) ↔ Tendsto (fun x => edist (f x) y) l (𝓝 0)
Theorem: Turing.TM1.stmts₁_self
File: Mathlib/Computability/TuringMachine.lean

tactic: cases q <;> simp only [stmts₁, Finset.mem_insert_self, Finset.mem_singleton_self]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
q : Stmt₁
⊢ q ∈ stmts₁ q
Theorem: MulOpposite.semiconjBy_unop
File: Mathlib/Algebra/Group/Opposite.lean

tactic: conv_rhs => rw [← op_unop a, ← op_unop x, ← op_unop y, semiconjBy_op]
state_before: α : Type u
inst✝ : Mul α
a x y : αᵐᵒᵖ
⊢ SemiconjBy (unop a) (unop y) (unop x) ↔ SemiconjBy a x y
Theorem: Nat.add_factorial_succ_lt_factorial_add_succ
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [← Nat.succ_eq_add_one (i + _), factorial_succ (i + _), add_mul, one_mul]
state_before: m n✝ i n : ℕ
hi : 2 ≤ i
⊢ i + (n + 1)! < (i + n + 1)!

tactic: have : i ≤ i + n := le.intro rfl
state_before: m n✝ i n : ℕ
hi : 2 ≤ i
⊢ i + (n + 1)! < (i + n) * (i + n)! + (i + n)!

tactic: exact
  add_lt_add_of_lt_of_le
    (this.trans_lt
      ((lt_mul_iff_one_lt_right ((by decide : 0 < 2).trans_le (hi.trans this))).mpr
        (lt_iff_le_and_ne.mpr
          ⟨(i + n).factorial_pos, fun g =>
            Nat.not_succ_le_self 1 ((hi.trans this).trans (factorial_eq_one.mp g.symm))⟩)))
    (factorial_le
      ((le_of_eq (add_comm n 1)).trans
      ((add_le_add_iff_right n).mpr ((by decide : 1 ≤ 2).trans hi))))
state_before: m n✝ i n : ℕ
hi : 2 ≤ i
this : i ≤ i + n
⊢ i + (n + 1)! < (i + n) * (i + n)! + (i + n)!

tactic: decide
state_before: m n✝ i n : ℕ
hi : 2 ≤ i
this : i ≤ i + n
⊢ 0 < 2

tactic: decide
state_before: m n✝ i n : ℕ
hi : 2 ≤ i
this : i ≤ i + n
⊢ 1 ≤ 2
Theorem: Ideal.mem_leadingCoeffNth_zero
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: rwa [← hpx, Polynomial.leadingCoeff,
  Nat.eq_zero_of_le_zero (natDegree_le_of_degree_le hpdeg), ← eq_C_of_degree_le_zero hpdeg]
state_before: R : Type u
S : Type ?u.136653
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
x✝ : ∃ p, p ∈ I ∧ degree p ≤ ↑0 ∧ Polynomial.leadingCoeff p = x
p : R[X]
hpI : p ∈ I
hpdeg : degree p ≤ ↑0
hpx : Polynomial.leadingCoeff p = x
⊢ ↑C x ∈ I
Theorem: continuousAt_codRestrict_iff
File: Mathlib/Topology/Constructions.lean

tactic: simp_rw [inducing_subtype_val.continuousAt_iff, Function.comp, val_codRestrict_apply]
state_before: α : Type u
β : Type v
γ : Type ?u.160981
δ : Type ?u.160984
ε : Type ?u.160987
ζ : Type ?u.160990
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
p : α → Prop
f : α → β
t : Set β
h1 : ∀ (x : α), f x ∈ t
x : α
⊢ ContinuousAt (codRestrict f t h1) x ↔ ContinuousAt f x
Theorem: IsLocalization.mem_invSubmonoid_iff_exists_mk'
File: Mathlib/RingTheory/Localization/InvSubmonoid.lean

tactic: simp_rw [← toInvSubmonoid_eq_mk']
state_before: R : Type u_2
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_1
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type ?u.238086
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
x : S
⊢ x ∈ invSubmonoid M S ↔ ∃ m, mk' S 1 m = x

tactic: exact ⟨fun h => ⟨_, congr_arg Subtype.val (toInvSubmonoid_surjective M S ⟨x, h⟩).choose_spec⟩,
  fun h => h.choose_spec ▸ (toInvSubmonoid M S h.choose).prop⟩
state_before: R : Type u_2
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_1
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type ?u.238086
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
x : S
⊢ x ∈ invSubmonoid M S ↔ ∃ m, ↑(↑(toInvSubmonoid M S) m) = x
Theorem: CategoryTheory.dite_comp
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: aesop
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
P : Prop
inst✝ : Decidable P
X Y Z : C
f : P → (X ⟶ Y)
f' : ¬P → (X ⟶ Y)
g : Y ⟶ Z
⊢ (if h : P then f h else f' h) ≫ g = if h : P then f h ≫ g else f' h ≫ g
Theorem: TopologicalSpace.Closeds.iInf_def
File: Mathlib/Topology/Sets/Closeds.lean

tactic: ext1
state_before: ι✝ : Type ?u.17060
α : Type u_2
β : Type ?u.17066
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_1
s : ι → Closeds α
⊢ (⨅ (i : ι), s i) = { carrier := ⋂ (i : ι), ↑(s i), closed' := (_ : IsClosed (⋂ (i : ι), ↑(s i))) }

tactic: simp
state_before: case h
ι✝ : Type ?u.17060
α : Type u_2
β : Type ?u.17066
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_1
s : ι → Closeds α
⊢ ↑(⨅ (i : ι), s i) = ↑{ carrier := ⋂ (i : ι), ↑(s i), closed' := (_ : IsClosed (⋂ (i : ι), ↑(s i))) }
Theorem: AffineSubspace.mem_mk'_iff_vsub_mem
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: refine' ⟨fun h => _, fun h => _⟩
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
direction : Submodule k V
⊢ p₂ ∈ mk' p₁ direction ↔ p₂ -ᵥ p₁ ∈ direction

tactic: rw [← direction_mk' p₁ direction]
state_before: case refine'_1
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
direction : Submodule k V
h : p₂ ∈ mk' p₁ direction
⊢ p₂ -ᵥ p₁ ∈ direction

tactic: exact vsub_mem_direction h (self_mem_mk' _ _)
state_before: case refine'_1
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
direction : Submodule k V
h : p₂ ∈ mk' p₁ direction
⊢ p₂ -ᵥ p₁ ∈ AffineSubspace.direction (mk' p₁ direction)

tactic: rw [← vsub_vadd p₂ p₁]
state_before: case refine'_2
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
direction : Submodule k V
h : p₂ -ᵥ p₁ ∈ direction
⊢ p₂ ∈ mk' p₁ direction

tactic: exact vadd_mem_mk' p₁ h
state_before: case refine'_2
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
direction : Submodule k V
h : p₂ -ᵥ p₁ ∈ direction
⊢ p₂ -ᵥ p₁ +ᵥ p₁ ∈ mk' p₁ direction
Theorem: HilbertBasis.coe_mk
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: apply funext <| Orthonormal.linearIsometryEquiv_symm_apply_single_one hv hsp
state_before: ι : Type u_3
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type ?u.905970
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
v : ι → E
hv : Orthonormal 𝕜 v
hsp : ⊤ ≤ topologicalClosure (span 𝕜 (Set.range v))
⊢ (fun i => ↑(LinearIsometryEquiv.symm (HilbertBasis.mk hv hsp).repr) (lp.single 2 i 1)) = v