tasksource/leandojo huggingface dataset:
Theorem: Submodule.subsingleton_iff
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [← subsingleton_iff_bot_eq_top, ← subsingleton_iff_bot_eq_top, ← toAddSubmonoid_eq]
state_before: R : Type u_2
R₁ : Type ?u.396898
R₂ : Type ?u.396901
R₃ : Type ?u.396904
R₄ : Type ?u.396907
S : Type ?u.396910
K : Type ?u.396913
K₂ : Type ?u.396916
M : Type u_1
M' : Type ?u.396922
M₁ : Type ?u.396925
M₂ : Type ?u.396928
M₃ : Type ?u.396931
M₄ : Type ?u.396934
N : Type ?u.396937
N₂ : Type ?u.396940
ι : Type ?u.396943
V : Type ?u.396946
V₂ : Type ?u.396949
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
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₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
σ₂₁ : R₂ →+* R
inst✝² : RingHomInvPair σ₁₂ σ₂₁
inst✝¹ : RingHomInvPair σ₂₁ σ₁₂
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p p' : Submodule R M
q q' : Submodule R₂ M₂
q₁ q₁' : Submodule R M'
r : R
x y : M
⊢ Subsingleton (Submodule R M) ↔ Subsingleton (AddSubmonoid M)

tactic: rfl
state_before: R : Type u_2
R₁ : Type ?u.396898
R₂ : Type ?u.396901
R₃ : Type ?u.396904
R₄ : Type ?u.396907
S : Type ?u.396910
K : Type ?u.396913
K₂ : Type ?u.396916
M : Type u_1
M' : Type ?u.396922
M₁ : Type ?u.396925
M₂ : Type ?u.396928
M₃ : Type ?u.396931
M₄ : Type ?u.396934
N : Type ?u.396937
N₂ : Type ?u.396940
ι : Type ?u.396943
V : Type ?u.396946
V₂ : Type ?u.396949
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
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₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
σ₂₁ : R₂ →+* R
inst✝² : RingHomInvPair σ₁₂ σ₂₁
inst✝¹ : RingHomInvPair σ₂₁ σ₁₂
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p p' : Submodule R M
q q' : Submodule R₂ M₂
q₁ q₁' : Submodule R M'
r : R
x y : M
⊢ ⊥.toAddSubmonoid = ⊤.toAddSubmonoid ↔ ⊥ = ⊤
Theorem: List.id_traverse
File: Mathlib/Control/Traversable/Instances.lean

tactic: induction xs <;> simp! [*, List.traverse, functor_norm]
state_before: F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
xs : List α
⊢ List.traverse pure xs = xs

tactic: rfl
state_before: case cons
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
head✝ : α
tail✝ : List α
tail_ih✝ : List.traverse pure tail✝ = tail✝
⊢ (Seq.seq (cons head✝) fun x => tail✝) = head✝ :: tail✝
Theorem: MvPolynomial.totalDegree_finset_prod
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: refine' le_trans (totalDegree_multiset_prod _) _
state_before: R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.472102
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
s : Finset ι
f : ι → MvPolynomial σ R
⊢ totalDegree (Finset.prod s f) ≤ ∑ i in s, totalDegree (f i)

tactic: rw [Multiset.map_map]
state_before: R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.472102
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
s : Finset ι
f : ι → MvPolynomial σ R
⊢ Multiset.sum (Multiset.map totalDegree (Multiset.map f s.val)) ≤ ∑ i in s, totalDegree (f i)

tactic: rfl
state_before: R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.472102
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
s : Finset ι
f : ι → MvPolynomial σ R
⊢ Multiset.sum (Multiset.map (totalDegree ∘ f) s.val) ≤ ∑ i in s, totalDegree (f i)
Theorem: PiNat.dist_triangle_nonarch
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: rcases eq_or_ne x z with (rfl | hxz)
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
⊢ dist x z ≤ max (dist x y) (dist y z)

tactic: rcases eq_or_ne x y with (rfl | hxy)
state_before: case inr
E : ℕ → Type u_1
x y z : (n : ℕ) → E n
hxz : x ≠ z
⊢ dist x z ≤ max (dist x y) (dist y z)

tactic: rcases eq_or_ne y z with (rfl | hyz)
state_before: case inr.inr
E : ℕ → Type u_1
x y z : (n : ℕ) → E n
hxz : x ≠ z
hxy : x ≠ y
⊢ dist x z ≤ max (dist x y) (dist y z)

tactic: simp only [dist_eq_of_ne, hxz, hxy, hyz, inv_le_inv, one_div, inv_pow, zero_lt_two, Ne.def,
  not_false_iff, le_max_iff, pow_le_pow_iff, one_lt_two, pow_pos,
  min_le_iff.1 (min_firstDiff_le x y z hxz)]
state_before: case inr.inr.inr
E : ℕ → Type u_1
x y z : (n : ℕ) → E n
hxz : x ≠ z
hxy : x ≠ y
hyz : y ≠ z
⊢ dist x z ≤ max (dist x y) (dist y z)

tactic: simp [PiNat.dist_self x, PiNat.dist_nonneg]
state_before: case inl
E : ℕ → Type u_1
x y : (n : ℕ) → E n
⊢ dist x x ≤ max (dist x y) (dist y x)

tactic: simp
state_before: case inr.inl
E : ℕ → Type u_1
x z : (n : ℕ) → E n
hxz : x ≠ z
⊢ dist x z ≤ max (dist x x) (dist x z)

tactic: simp
state_before: case inr.inr.inl
E : ℕ → Type u_1
x y : (n : ℕ) → E n
hxy hxz : x ≠ y
⊢ dist x y ≤ max (dist x y) (dist y y)
Theorem: CategoryTheory.Equivalence.cancel_counit_right
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: simp only [cancel_mono]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
e : C ≌ D
X Y : D
f f' : X ⟶ e.functor.obj (e.inverse.obj Y)
⊢ f ≫ (counit e).app Y = f' ≫ (counit e).app Y ↔ f = f'
Theorem: ProbabilityTheory.kernel.set_integral_deterministic'
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [kernel.deterministic_apply, set_integral_dirac' hf _ hs]
state_before: α : Type u_2
β : Type u_3
ι : Type ?u.402176
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : { x // x ∈ kernel α β }
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : β → E
g : α → β
a : α
hg : Measurable g
hf : StronglyMeasurable f
s : Set β
hs : MeasurableSet s
inst✝ : Decidable (g a ∈ s)
⊢ (∫ (x : β) in s, f x ∂↑(deterministic g hg) a) = if g a ∈ s then f (g a) else 0
Theorem: SimpleGraph.bot_degree
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: erw [degree, neighborFinset_eq_filter, filter_False]
state_before: ι : Sort ?u.287178
𝕜 : Type ?u.287181
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝ : Fintype V
v : V
⊢ degree ⊥ v = 0

tactic: exact Finset.card_empty
state_before: ι : Sort ?u.287178
𝕜 : Type ?u.287181
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝ : Fintype V
v : V
⊢ card ∅ = 0
Theorem: CategoryTheory.Subobject.symm_apply_mem_iff_mem_image
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: simp
state_before: C : Type u₁
inst✝⁴ : Category C
X Y Z : C
D : Type u₂
inst✝³ : Category D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
α : Type u_1
β : Type u_2
e : α ≃ β
s : Set α
x : β
h : ↑e.symm x ∈ s
⊢ ↑e (↑e.symm x) = x

tactic: rintro ⟨a, m, rfl⟩
state_before: C : Type u₁
inst✝⁴ : Category C
X Y Z : C
D : Type u₂
inst✝³ : Category D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
α : Type u_1
β : Type u_2
e : α ≃ β
s : Set α
x : β
⊢ x ∈ ↑e '' s → ↑e.symm x ∈ s

tactic: simpa using m
state_before: case intro.intro
C : Type u₁
inst✝⁴ : Category C
X Y Z : C
D : Type u₂
inst✝³ : Category D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
α : Type u_1
β : Type u_2
e : α ≃ β
s : Set α
a : α
m : a ∈ s
⊢ ↑e.symm (↑e a) ∈ s
Theorem: List.dropLast_eq_take
File: Mathlib/Data/List/Basic.lean

tactic: cases' l with x l
state_before: ι : Type ?u.195932
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
⊢ dropLast l = take (pred (length l)) l

tactic: simp [dropLast]
state_before: case nil
ι : Type ?u.195932
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
⊢ dropLast [] = take (pred (length [])) []

tactic: induction' l with hd tl hl generalizing x
state_before: case cons
ι : Type ?u.195932
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x : α
l : List α
⊢ dropLast (x :: l) = take (pred (length (x :: l))) (x :: l)

tactic: simp [dropLast]
state_before: case cons.nil
ι : Type ?u.195932
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x✝ x : α
⊢ dropLast [x] = take (pred (length [x])) [x]

tactic: simp [dropLast, hl]
state_before: case cons.cons
ι : Type ?u.195932
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x✝ hd : α
tl : List α
hl : ∀ (x : α), dropLast (x :: tl) = take (pred (length (x :: tl))) (x :: tl)
x : α
⊢ dropLast (x :: hd :: tl) = take (pred (length (x :: hd :: tl))) (x :: hd :: tl)
Theorem: Function.support_div
File: Mathlib/Algebra/Support.lean

tactic: simp [div_eq_mul_inv]
state_before: α : Type u_2
β : Type ?u.97251
A : Type ?u.97254
B : Type ?u.97257
M : Type ?u.97260
N : Type ?u.97263
P : Type ?u.97266
R : Type ?u.97269
S : Type ?u.97272
G : Type ?u.97275
M₀ : Type ?u.97278
G₀ : Type u_1
ι : Sort ?u.97284
inst✝ : GroupWithZero G₀
f g : α → G₀
⊢ (support fun x => f x / g x) = support f ∩ support g
Theorem: Real.Angle.two_zsmul_ne_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← not_or, ← two_zsmul_eq_zero_iff]
state_before: θ : Angle
⊢ 2 • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ ↑π
Theorem: Filter.Tendsto.mul_atBot
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: simpa only [mul_comm] using hg.atBot_mul hC hf
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l (𝓝 C)
hg : Tendsto g l atBot
⊢ Tendsto (fun x => f x * g x) l atBot
Theorem: CategoryTheory.zero_not_simple
File: Mathlib/CategoryTheory/Simple.lean

tactic: aesop_cat
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
inst✝ : Simple 0
⊢ 0 ≫ 0 = 𝟙 0 ∧ 0 ≫ 0 = 𝟙 0
Theorem: ENNReal.hasSum_iff_tendsto_nat
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: refine' ⟨HasSum.tendsto_sum_nat, fun h => _⟩
state_before: α : Type ?u.258802
β : Type ?u.258805
γ : Type ?u.258808
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : ℕ → ℝ≥0∞
r : ℝ≥0∞
⊢ HasSum f r ↔ Tendsto (fun n => ∑ i in Finset.range n, f i) atTop (𝓝 r)

tactic: rw [← iSup_eq_of_tendsto _ h, ← ENNReal.tsum_eq_iSup_nat]
state_before: α : Type ?u.258802
β : Type ?u.258805
γ : Type ?u.258808
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : ℕ → ℝ≥0∞
r : ℝ≥0∞
h : Tendsto (fun n => ∑ i in Finset.range n, f i) atTop (𝓝 r)
⊢ HasSum f r

tactic: exact ENNReal.summable.hasSum
state_before: α : Type ?u.258802
β : Type ?u.258805
γ : Type ?u.258808
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : ℕ → ℝ≥0∞
r : ℝ≥0∞
h : Tendsto (fun n => ∑ i in Finset.range n, f i) atTop (𝓝 r)
⊢ HasSum f (∑' (i : ℕ), f i)

tactic: exact fun s t hst => Finset.sum_le_sum_of_subset (Finset.range_subset.2 hst)
state_before: α : Type ?u.258802
β : Type ?u.258805
γ : Type ?u.258808
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : ℕ → ℝ≥0∞
r : ℝ≥0∞
h : Tendsto (fun n => ∑ i in Finset.range n, f i) atTop (𝓝 r)
⊢ Monotone fun n => ∑ i in Finset.range n, f i
Theorem: Cardinal.power_nat_eq
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: exact_mod_cast h2
state_before: c : Cardinal
n : ℕ
h1 : ℵ₀ ≤ c
h2 : 1 ≤ n
⊢ 1 ≤ ↑n
Theorem: Finset.affineCombination_map
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp_rw [affineCombination_apply, weightedVSubOfPoint_map]
state_before: k : Type u_4
V : Type u_5
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type u_1
s₂ : Finset ι₂
e : ι₂ ↪ ι
w : ι → k
p : ι → P
⊢ ↑(affineCombination k (map e s₂) p) w = ↑(affineCombination k s₂ (p ∘ ↑e)) (w ∘ ↑e)
Theorem: LocalEquiv.eq_symm_apply
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: rw [← e.right_inv hy, h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.20183
δ : Type ?u.20186
e : LocalEquiv α β
e' : LocalEquiv β γ
x : α
y : β
hx : x ∈ e.source
hy : y ∈ e.target
h : x = ↑(LocalEquiv.symm e) y
⊢ ↑e x = y

tactic: rw [← e.left_inv hx, h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.20183
δ : Type ?u.20186
e : LocalEquiv α β
e' : LocalEquiv β γ
x : α
y : β
hx : x ∈ e.source
hy : y ∈ e.target
h : ↑e x = y
⊢ x = ↑(LocalEquiv.symm e) y
Theorem: Finset.uIcc_of_le
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [uIcc, inf_eq_left.2 h, sup_eq_right.2 h]
state_before: ι : Type ?u.172384
α : Type u_1
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : a ≤ b
⊢ [[a, b]] = Icc a b
Theorem: MeasureTheory.MeasurePreserving.measure_preimage_emb
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

tactic: rw [← hf.map_eq, hfe.map_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.271746
δ : Type ?u.271749
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
f : α → β
hf : MeasurePreserving f
hfe : MeasurableEmbedding f
s : Set β
⊢ ↑↑μa (f ⁻¹' s) = ↑↑μb s
Theorem: Rat.preimage_cast_Ici
File: Mathlib/Data/Rat/Cast.lean

tactic: ext x
state_before: F : Type ?u.76773
ι : Type ?u.76776
α : Type ?u.76779
β : Type ?u.76782
K : Type u_1
inst✝ : LinearOrderedField K
a : ℚ
⊢ Rat.cast ⁻¹' Ici ↑a = Ici a

tactic: simp
state_before: case h
F : Type ?u.76773
ι : Type ?u.76776
α : Type ?u.76779
β : Type ?u.76782
K : Type u_1
inst✝ : LinearOrderedField K
a x : ℚ
⊢ x ∈ Rat.cast ⁻¹' Ici ↑a ↔ x ∈ Ici a
Theorem: CategoryTheory.Subobject.ofLE_comp_ofLE
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp only [ofLE, ← Functor.map_comp underlying]
state_before: C : Type u₁
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category D
B : C
X Y Z : Subobject B
h₁ : X ≤ Y
h₂ : Y ≤ Z
⊢ ofLE X Y h₁ ≫ ofLE Y Z h₂ = ofLE X Z (_ : X ≤ Z)

tactic: congr 1
state_before: C : Type u₁
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category D
B : C
X Y Z : Subobject B
h₁ : X ≤ Y
h₂ : Y ≤ Z
⊢ underlying.map (LE.le.hom h₁ ≫ LE.le.hom h₂) = underlying.map (LE.le.hom (_ : X ≤ Z))
Theorem: IsCyclic.image_range_card
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: rw [← orderOf_eq_card_of_forall_mem_zpowers ha, IsCyclic.image_range_orderOf ha]
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
ha : ∀ (x : α), x ∈ zpowers a
⊢ image (fun i => a ^ i) (range (Fintype.card α)) = univ
Theorem: Int.lt_div_add_one_mul_self
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.add_mul, Int.one_mul, Int.mul_comm]
state_before: a b : Int
H : 0 < b
⊢ a < (div a b + 1) * b

tactic: exact Int.lt_add_of_sub_left_lt <| Int.mod_def .. ▸ mod_lt_of_pos _ H
state_before: a b : Int
H : 0 < b
⊢ a < b * div a b + b
Theorem: IsCoprime.dvd_of_dvd_mul_left
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: let ⟨a, b, H⟩ := H1
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H1 : IsCoprime x y
H2 : x ∣ y * z
⊢ x ∣ z

tactic: rw [← one_mul z, ← H, add_mul, mul_right_comm, mul_assoc b]
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H1 : IsCoprime x y
H2 : x ∣ y * z
a b : R
H : a * x + b * y = 1
⊢ x ∣ z

tactic: exact dvd_add (dvd_mul_left _ _) (H2.mul_left _)
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H1 : IsCoprime x y
H2 : x ∣ y * z
a b : R
H : a * x + b * y = 1
⊢ x ∣ a * z * x + b * (y * z)
Theorem: Units.mul_right_dvd
File: Mathlib/Algebra/Divisibility/Units.lean

tactic: rw [mul_assoc, u.mul_inv, mul_one]
state_before: α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
h : a ∣ b
⊢ a * ↑u * ↑u⁻¹ = a
Theorem: max_div_div_right'
File: Mathlib/Algebra/Order/Group/MinMax.lean

tactic: simpa only [div_eq_mul_inv] using max_mul_mul_right a b c⁻¹
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b✝ c✝ a b c : α
⊢ max (a / c) (b / c) = max a b / c
Theorem: CategoryTheory.tensorRightHomEquiv_symm_naturality
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: dsimp [tensorRightHomEquiv]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : X ⟶ X'
g : X' ⟶ Z ⊗ Y'
⊢ ↑(tensorRightHomEquiv X Y Y' Z).symm (f ≫ g) = (f ⊗ 𝟙 Y) ≫ ↑(tensorRightHomEquiv X' Y Y' Z).symm g

tactic: simp only [comp_tensor_id, Category.assoc]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : X ⟶ X'
g : X' ⟶ Z ⊗ Y'
⊢ (f ≫ g ⊗ 𝟙 Y) ≫ (α_ Z Y' Y).hom ≫ (𝟙 Z ⊗ ε_ Y Y') ≫ (ρ_ Z).hom =
    (f ⊗ 𝟙 Y) ≫ (g ⊗ 𝟙 Y) ≫ (α_ Z Y' Y).hom ≫ (𝟙 Z ⊗ ε_ Y Y') ≫ (ρ_ Z).hom
Theorem: Complex.cosh_two_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [two_mul, cosh_add, sq, sq]
state_before: x y : ℂ
⊢ cosh (2 * x) = cosh x ^ 2 + sinh x ^ 2
Theorem: List.duplicate_iff_sublist
File: Mathlib/Data/List/Duplicate.lean

tactic: induction' l with y l IH
state_before: α : Type u_1
l : List α
x : α
⊢ x ∈+ l ↔ [x, x] <+ l

tactic: simp
state_before: case nil
α : Type u_1
l : List α
x : α
⊢ x ∈+ [] ↔ [x, x] <+ []

tactic: by_cases hx : x = y
state_before: case cons
α : Type u_1
l✝ : List α
x y : α
l : List α
IH : x ∈+ l ↔ [x, x] <+ l
⊢ x ∈+ y :: l ↔ [x, x] <+ y :: l

tactic: simp [hx, cons_sublist_cons_iff, singleton_sublist]
state_before: case pos
α : Type u_1
l✝ : List α
x y : α
l : List α
IH : x ∈+ l ↔ [x, x] <+ l
hx : x = y
⊢ x ∈+ y :: l ↔ [x, x] <+ y :: l

tactic: rw [duplicate_cons_iff_of_ne hx, IH]
state_before: case neg
α : Type u_1
l✝ : List α
x y : α
l : List α
IH : x ∈+ l ↔ [x, x] <+ l
hx : ¬x = y
⊢ x ∈+ y :: l ↔ [x, x] <+ y :: l

tactic: refine' ⟨sublist_cons_of_sublist y, fun h => _⟩
state_before: case neg
α : Type u_1
l✝ : List α
x y : α
l : List α
IH : x ∈+ l ↔ [x, x] <+ l
hx : ¬x = y
⊢ [x, x] <+ l ↔ [x, x] <+ y :: l

tactic: cases h
state_before: case neg
α : Type u_1
l✝ : List α
x y : α
l : List α
IH : x ∈+ l ↔ [x, x] <+ l
hx : ¬x = y
h : [x, x] <+ y :: l
⊢ [x, x] <+ l

tactic: assumption
state_before: case neg.cons
α : Type u_1
l✝ : List α
x y : α
l : List α
IH : x ∈+ l ↔ [x, x] <+ l
hx : ¬x = y
a✝ : [x, x] <+ l
⊢ [x, x] <+ l

tactic: contradiction
state_before: case neg.cons₂
α : Type u_1
l✝ : List α
x : α
l : List α
IH : x ∈+ l ↔ [x, x] <+ l
hx : ¬x = x
a✝ : [x] <+ l
⊢ [x, x] <+ l
Theorem: gold_sq
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [goldenRatio, ← sub_eq_zero]
state_before: ⊢ φ ^ 2 = φ + 1

tactic: ring_nf
state_before: ⊢ ((1 + sqrt 5) / 2) ^ 2 - ((1 + sqrt 5) / 2 + 1) = 0

tactic: rw [Real.sq_sqrt] <;> norm_num
state_before: ⊢ sqrt 5 ^ 2 * (↑(Int.ofNat 1) / ↑4) + ↑(Int.negOfNat 5) * (↑(Int.ofNat 1) / ↑4) = 0
Theorem: RatFunc.coe_smul
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [smul_eq_C_mul, ← C_mul_eq_smul, coe_mul, coe_C]
state_before: K F : Type u
inst✝ : Field F
p q : F[X]
f g : RatFunc F
r : F
⊢ ↑(r • f) = r • ↑f
Theorem: MulLECancellable.le_mul_iff_one_le_right
File: Mathlib/Algebra/Order/Monoid/Lemmas.lean

tactic: rw [mul_one]
state_before: α : Type u_1
β : Type ?u.87217
inst✝² : LE α
inst✝¹ : MulOneClass α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
ha : MulLECancellable a
⊢ a ≤ a * b ↔ a * 1 ≤ a * b
Theorem: Class.congToClass_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: ext z
state_before: ⊢ congToClass ∅ = ∅

tactic: simp only [congToClass, not_empty_hom, iff_false_iff]
state_before: case a
z : ZFSet
⊢ congToClass ∅ z ↔ ∅ z

tactic: exact Set.not_mem_empty z
state_before: case a
z : ZFSet
⊢ ¬setOf (fun y => ↑y ∈ ∅) z
Theorem: Dense.prod
File: Mathlib/Topology/Constructions.lean

tactic: rw [closure_prod_eq]
state_before: α : Type u
β : Type v
γ : Type ?u.63807
δ : Type ?u.63810
ε : Type ?u.63813
ζ : Type ?u.63816
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set α
t : Set β
hs : Dense s
ht : Dense t
x : α × β
⊢ x ∈ closure (s ×ˢ t)

tactic: exact ⟨hs x.1, ht x.2⟩
state_before: α : Type u
β : Type v
γ : Type ?u.63807
δ : Type ?u.63810
ε : Type ?u.63813
ζ : Type ?u.63816
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set α
t : Set β
hs : Dense s
ht : Dense t
x : α × β
⊢ x ∈ closure s ×ˢ closure t
Theorem: Fin.pred_mk_succ
File: Mathlib/Data/Fin/Basic.lean

tactic: simp only [ext_iff, coe_pred, add_tsub_cancel_right]
state_before: n m i : ℕ
h : i < n + 1
⊢ pred { val := i + 1, isLt := (_ : i + 1 < n + 1 + 1) } (_ : { val := i + 1, isLt := (_ : i + 1 < n + 1 + 1) } ≠ 0) =
    { val := i, isLt := h }
Theorem: List.tendsto_removeNth
File: Mathlib/Topology/List.lean

tactic: rw [nhds_nil]
state_before: α : Type u_1
β : Type ?u.54838
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
x✝ : ℕ
⊢ Tendsto (fun l => removeNth l x✝) (𝓝 []) (𝓝 (removeNth [] x✝))

tactic: exact tendsto_pure_nhds _ _
state_before: α : Type u_1
β : Type ?u.54838
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
x✝ : ℕ
⊢ Tendsto (fun l => removeNth l x✝) (pure []) (𝓝 (removeNth [] x✝))

tactic: rw [tendsto_cons_iff]
state_before: α : Type u_1
β : Type ?u.54838
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a : α
l : List α
⊢ Tendsto (fun l => removeNth l 0) (𝓝 (a :: l)) (𝓝 (removeNth (a :: l) 0))

tactic: exact tendsto_snd
state_before: α : Type u_1
β : Type ?u.54838
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a : α
l : List α
⊢ Tendsto (fun p => removeNth (p.fst :: p.snd) 0) (𝓝 a ×ˢ 𝓝 l) (𝓝 (removeNth (a :: l) 0))

tactic: rw [tendsto_cons_iff]
state_before: α : Type u_1
β : Type ?u.54838
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
a : α
l : List α
⊢ Tendsto (fun l => removeNth l (n + 1)) (𝓝 (a :: l)) (𝓝 (removeNth (a :: l) (n + 1)))

tactic: dsimp [removeNth]
state_before: α : Type u_1
β : Type ?u.54838
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
a : α
l : List α
⊢ Tendsto (fun p => removeNth (p.fst :: p.snd) (n + 1)) (𝓝 a ×ˢ 𝓝 l) (𝓝 (removeNth (a :: l) (n + 1)))

tactic: exact tendsto_fst.cons ((@tendsto_removeNth n l).comp tendsto_snd)
state_before: α : Type u_1
β : Type ?u.54838
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
a : α
l : List α
⊢ Tendsto (fun p => p.fst :: removeNth p.snd n) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a :: removeNth l n))
Theorem: one_div_lt_neg_one
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [one_div_neg_one_eq_neg_one] at this
state_before: ι : Type ?u.181515
α : Type u_1
β : Type ?u.181521
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
h1 : a < 0
h2 : -1 < a
this : 1 / a < 1 / -1
⊢ 1 / a < -1