tasksource/leandojo huggingface dataset:
Theorem: IsGenericPoint.mem_closed_set_iff
File: Mathlib/Topology/Sober.lean

tactic: rw [← h.def, hZ.closure_subset_iff, singleton_subset_iff]
state_before: α : Type u_1
β : Type ?u.2539
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
x y : α
S U Z : Set α
h : IsGenericPoint x S
hZ : IsClosed Z
⊢ x ∈ Z ↔ S ⊆ Z
Theorem: Rat.divInt_mul_divInt_cancel
File: Mathlib/Data/Rat/Defs.lean

tactic: by_cases hd : d = 0
state_before: a b c : ℚ
x : ℤ
hx : x ≠ 0
n d : ℤ
⊢ n /. x * (x /. d) = n /. d

tactic: rw [mul_def' hx hd, mul_comm x, divInt_mul_right hx]
state_before: case neg
a b c : ℚ
x : ℤ
hx : x ≠ 0
n d : ℤ
hd : ¬d = 0
⊢ n /. x * (x /. d) = n /. d

tactic: rw [hd]
state_before: case pos
a b c : ℚ
x : ℤ
hx : x ≠ 0
n d : ℤ
hd : d = 0
⊢ n /. x * (x /. d) = n /. d

tactic: simp
state_before: case pos
a b c : ℚ
x : ℤ
hx : x ≠ 0
n d : ℤ
hd : d = 0
⊢ n /. x * (x /. 0) = n /. 0
Theorem: Equiv.Perm.Disjoint.symm
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: simp only [Disjoint, or_comm, imp_self]
state_before: α : Type u_1
f g h : Perm α
⊢ Disjoint f g → Disjoint g f
Theorem: CategoryTheory.Limits.IsInitial.mono_from
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: rw [hI.hom_ext f (hI.to X)]
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : InitialMonoClass C
I X : C
hI : IsInitial I
f : I ⟶ X
⊢ Mono f

tactic: apply InitialMonoClass.isInitial_mono_from
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : InitialMonoClass C
I X : C
hI : IsInitial I
f : I ⟶ X
⊢ Mono (to hI X)
Theorem: Homeomorph.comp_isOpenMap_iff
File: Mathlib/Topology/Homeomorph.lean

tactic: refine' ⟨_, fun hf => h.isOpenMap.comp hf⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.72267
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
h : α ≃ₜ β
f : γ → α
⊢ IsOpenMap (↑h ∘ f) ↔ IsOpenMap f

tactic: intro hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.72267
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
h : α ≃ₜ β
f : γ → α
⊢ IsOpenMap (↑h ∘ f) → IsOpenMap f

tactic: rw [← Function.comp.left_id f, ← h.symm_comp_self, Function.comp.assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.72267
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
h : α ≃ₜ β
f : γ → α
hf : IsOpenMap (↑h ∘ f)
⊢ IsOpenMap f

tactic: exact h.symm.isOpenMap.comp hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.72267
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
h : α ≃ₜ β
f : γ → α
hf : IsOpenMap (↑h ∘ f)
⊢ IsOpenMap (↑(Homeomorph.symm h) ∘ ↑h ∘ f)
Theorem: Quaternion.normSq_smul
File: Mathlib/Algebra/Quaternion.lean

tactic: simp only [normSq_def', smul_re, smul_imI, smul_imJ, smul_imK, mul_pow, mul_add, smul_eq_mul]
state_before: S : Type ?u.864368
T : Type ?u.864371
R : Type u_1
inst✝ : CommRing R
r✝ x y z : R
a b c : ℍ[R]
r : R
q : ℍ[R]
⊢ ↑normSq (r • q) = r ^ 2 * ↑normSq q
Theorem: ENNReal.rpow_lt_one_of_one_lt_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases x
state_before: x : ℝ≥0∞
z : ℝ
hx : 1 < x
hz : z < 0
⊢ x ^ z < 1

tactic: simp [top_rpow_of_neg hz, zero_lt_one]
state_before: case none
z : ℝ
hz : z < 0
hx : 1 < none
⊢ none ^ z < 1

tactic: simp only [some_eq_coe, one_lt_coe_iff] at hx
state_before: case some
z : ℝ
hz : z < 0
val✝ : ℝ≥0
hx : 1 < Option.some val✝
⊢ Option.some val✝ ^ z < 1

tactic: simp [coe_rpow_of_ne_zero (ne_of_gt (lt_trans zero_lt_one hx)),
  NNReal.rpow_lt_one_of_one_lt_of_neg hx hz]
state_before: case some
z : ℝ
hz : z < 0
val✝ : ℝ≥0
hx : 1 < val✝
⊢ Option.some val✝ ^ z < 1
Theorem: Finset.prod_finset_product_right
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: refine' Eq.trans _ (prod_sigma s t fun p => f (p.2, p.1))
state_before: ι : Type ?u.318416
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
r : Finset (α × γ)
s : Finset γ
t : γ → Finset α
h : ∀ (p : α × γ), p ∈ r ↔ p.snd ∈ s ∧ p.fst ∈ t p.snd
f : α × γ → β
⊢ ∏ p in r, f p = ∏ c in s, ∏ a in t c, f (a, c)

tactic: exact
  prod_bij' (fun p _hp => ⟨p.2, p.1⟩) (fun p => mem_sigma.mpr ∘ (h p).mp)
    (fun p hp => congr_arg f Prod.mk.eta.symm) (fun p _hp => (p.2, p.1))
    (fun p => (h (p.2, p.1)).mpr ∘ mem_sigma.mp) (fun p _hp => Prod.mk.eta) fun p _hp => p.eta
state_before: ι : Type ?u.318416
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
r : Finset (α × γ)
s : Finset γ
t : γ → Finset α
h : ∀ (p : α × γ), p ∈ r ↔ p.snd ∈ s ∧ p.fst ∈ t p.snd
f : α × γ → β
⊢ ∏ p in r, f p = ∏ x in Finset.sigma s t, f (x.snd, x.fst)
Theorem: List.append_eq_cons_iff
File: Mathlib/Data/List/Basic.lean

tactic: cases a <;>
  simp only [and_assoc, @eq_comm _ c, nil_append, cons_append, cons.injEq, true_and_iff,
    false_and_iff, exists_false, false_or_iff, or_false_iff, exists_and_left, exists_eq_left']
state_before: ι : Type ?u.10352
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ a b c : List α
x : α
⊢ a ++ b = x :: c ↔ a = [] ∧ b = x :: c ∨ ∃ a', a = x :: a' ∧ c = a' ++ b
Theorem: Quaternion.self_mul_star
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [mul_star_eq_coe, normSq_def]
state_before: S : Type ?u.725571
T : Type ?u.725574
R : Type u_1
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
⊢ a * star a = ↑(↑normSq a)
Theorem: DenseInducing.comap_nhds_neBot
File: Mathlib/Topology/DenseEmbedding.lean

tactic: rcases mem_closure_iff_nhds.1 (di.dense b) s hs with ⟨_, ⟨ha, a, rfl⟩⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.5500
δ : Type ?u.5503
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
inst✝ : TopologicalSpace δ
f : γ → α
g : γ → δ
h : δ → β
di : DenseInducing i
b : β
s : Set β
hs : s ∈ 𝓝 b
⊢ ∃ a, i a ∈ s

tactic: exact ⟨a, ha⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.5500
δ : Type ?u.5503
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
inst✝ : TopologicalSpace δ
f : γ → α
g : γ → δ
h : δ → β
di : DenseInducing i
b : β
s : Set β
hs : s ∈ 𝓝 b
a : α
ha : i a ∈ s
⊢ ∃ a, i a ∈ s
Theorem: extChartAt_target_subset_range
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: simp only [mfld_simps]
state_before: 𝕜 : Type u_3
E : Type u_1
M : Type u_2
H : Type u_4
E' : Type ?u.199765
M' : Type ?u.199768
H' : Type ?u.199771
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
inst✝¹ : ChartedSpace H M
inst✝ : ChartedSpace H' M'
⊢ (extChartAt I x).target ⊆ range ↑I
Theorem: Finset.sigma_eq_empty
File: Mathlib/Data/Finset/Sigma.lean

tactic: simp only [← not_nonempty_iff_eq_empty, sigma_nonempty, not_exists, not_and]
state_before: ι : Type u_1
α : ι → Type u_2
β : Type ?u.6768
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
⊢ Finset.sigma s t = ∅ ↔ ∀ (i : ι), i ∈ s → t i = ∅
Theorem: Uniform.continuousWithinAt_iff'_left
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [ContinuousWithinAt, tendsto_nhds_left]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.198918
inst✝¹ : UniformSpace α
inst✝ : TopologicalSpace β
f : β → α
b : β
s : Set β
⊢ ContinuousWithinAt f s b ↔ Tendsto (fun x => (f x, f b)) (𝓝[s] b) (𝓤 α)
Theorem: CategoryTheory.Functor.preservesEpimorphisms_of_map_exact
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: letI := preservesZeroMorphisms_of_map_exact L h
state_before: C : Type u₁
inst✝⁵ : Category C
inst✝⁴ : Abelian C
A : Type u₁
B : Type u₂
inst✝³ : Category A
inst✝² : Category B
inst✝¹ : Abelian A
inst✝ : Abelian B
L : A ⥤ B
h : ∀ ⦃X Y Z : A⦄ {f : X ⟶ Y} {g : Y ⟶ Z}, Exact f g → Exact (L.map f) (L.map g)
X✝ Y✝ : A
f : X✝ ⟶ Y✝
hf : Epi f
⊢ Epi (L.map f)

tactic: apply ((tfae_epi (L.obj 0) (L.map f)).out 2 0).mp
state_before: C : Type u₁
inst✝⁵ : Category C
inst✝⁴ : Abelian C
A : Type u₁
B : Type u₂
inst✝³ : Category A
inst✝² : Category B
inst✝¹ : Abelian A
inst✝ : Abelian B
L : A ⥤ B
h : ∀ ⦃X Y Z : A⦄ {f : X ⟶ Y} {g : Y ⟶ Z}, Exact f g → Exact (L.map f) (L.map g)
X✝ Y✝ : A
f : X✝ ⟶ Y✝
hf : Epi f
this : PreservesZeroMorphisms L := preservesZeroMorphisms_of_map_exact L h
⊢ Epi (L.map f)

tactic: rw [← L.map_zero]
state_before: C : Type u₁
inst✝⁵ : Category C
inst✝⁴ : Abelian C
A : Type u₁
B : Type u₂
inst✝³ : Category A
inst✝² : Category B
inst✝¹ : Abelian A
inst✝ : Abelian B
L : A ⥤ B
h : ∀ ⦃X Y Z : A⦄ {f : X ⟶ Y} {g : Y ⟶ Z}, Exact f g → Exact (L.map f) (L.map g)
X✝ Y✝ : A
f : X✝ ⟶ Y✝
hf : Epi f
this : PreservesZeroMorphisms L := preservesZeroMorphisms_of_map_exact L h
⊢ Exact (L.map f) 0

tactic: exact h (((tfae_epi 0 f).out 0 2).mp hf)
state_before: C : Type u₁
inst✝⁵ : Category C
inst✝⁴ : Abelian C
A : Type u₁
B : Type u₂
inst✝³ : Category A
inst✝² : Category B
inst✝¹ : Abelian A
inst✝ : Abelian B
L : A ⥤ B
h : ∀ ⦃X Y Z : A⦄ {f : X ⟶ Y} {g : Y ⟶ Z}, Exact f g → Exact (L.map f) (L.map g)
X✝ Y✝ : A
f : X✝ ⟶ Y✝
hf : Epi f
this : PreservesZeroMorphisms L := preservesZeroMorphisms_of_map_exact L h
⊢ Exact (L.map f) (L.map 0)
Theorem: Matrix.det_eq_elem_of_subsingleton
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: have := uniqueOfSubsingleton k
state_before: m : Type ?u.185871
n : Type u_1
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : Subsingleton n
A : Matrix n n R
k : n
⊢ det A = A k k

tactic: convert det_unique A
state_before: m : Type ?u.185871
n : Type u_1
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : Subsingleton n
A : Matrix n n R
k : n
this : Unique n
⊢ det A = A k k
Theorem: Matrix.range_diagonal
File: Mathlib/LinearAlgebra/Matrix/Diagonal.lean

tactic: dsimp only [mem_setOf_eq]
state_before: m : Type u_1
n : Type ?u.147890
inst✝³ : Fintype m
inst✝² : Fintype n
K : Type u
inst✝¹ : Semifield K
inst✝ : DecidableEq m
w : m → K
⊢ LinearMap.range (↑toLin' (diagonal w)) =
    ⨆ (i : m) (_ : i ∈ {i | w i ≠ 0}), LinearMap.range (LinearMap.stdBasis K (fun x => K) i)

tactic: rw [← Submodule.map_top, ← iSup_range_stdBasis, Submodule.map_iSup]
state_before: m : Type u_1
n : Type ?u.147890
inst✝³ : Fintype m
inst✝² : Fintype n
K : Type u
inst✝¹ : Semifield K
inst✝ : DecidableEq m
w : m → K
⊢ LinearMap.range (↑toLin' (diagonal w)) =
    ⨆ (i : m) (_ : w i ≠ 0), LinearMap.range (LinearMap.stdBasis K (fun x => K) i)

tactic: congr
state_before: m : Type u_1
n : Type ?u.147890
inst✝³ : Fintype m
inst✝² : Fintype n
K : Type u
inst✝¹ : Semifield K
inst✝ : DecidableEq m
w : m → K
⊢ (⨆ (i : m), Submodule.map (↑toLin' (diagonal w)) (LinearMap.range (LinearMap.stdBasis K (fun a => K) i))) =
    ⨆ (i : m) (_ : w i ≠ 0), LinearMap.range (LinearMap.stdBasis K (fun x => K) i)

tactic: funext i
state_before: case e_s
m : Type u_1
n : Type ?u.147890
inst✝³ : Fintype m
inst✝² : Fintype n
K : Type u
inst✝¹ : Semifield K
inst✝ : DecidableEq m
w : m → K
⊢ (fun i => Submodule.map (↑toLin' (diagonal w)) (LinearMap.range (LinearMap.stdBasis K (fun a => K) i))) = fun i =>
    ⨆ (_ : w i ≠ 0), LinearMap.range (LinearMap.stdBasis K (fun x => K) i)

tactic: rw [← LinearMap.range_comp, diagonal_comp_stdBasis, ← range_smul']
state_before: case e_s.h
m : Type u_1
n : Type ?u.147890
inst✝³ : Fintype m
inst✝² : Fintype n
K : Type u
inst✝¹ : Semifield K
inst✝ : DecidableEq m
w : m → K
i : m
⊢ Submodule.map (↑toLin' (diagonal w)) (LinearMap.range (LinearMap.stdBasis K (fun a => K) i)) =
    ⨆ (_ : w i ≠ 0), LinearMap.range (LinearMap.stdBasis K (fun x => K) i)
Theorem: geom_sum_Ico'
File: Mathlib/Algebra/GeomSum.lean

tactic: simp only [geom_sum_Ico hx hmn]
state_before: α : Type u
inst✝ : DivisionRing α
x : α
hx : x ≠ 1
m n : ℕ
hmn : m ≤ n
⊢ ∑ i in Ico m n, x ^ i = (x ^ m - x ^ n) / (1 - x)

tactic: convert neg_div_neg_eq (x ^ m - x ^ n) (1 - x) using 2 <;> abel
state_before: α : Type u
inst✝ : DivisionRing α
x : α
hx : x ≠ 1
m n : ℕ
hmn : m ≤ n
⊢ (x ^ n - x ^ m) / (x - 1) = (x ^ m - x ^ n) / (1 - x)
Theorem: Rack.self_act_eq_iff_eq
File: Mathlib/Algebra/Quandle.lean

tactic: constructor
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y ↔ x = y

tactic: swap
state_before: case mp
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y → x = y

case mpr
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x = y → x ◃ x = y ◃ y

tactic: rintro rfl
state_before: case mpr
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x = y → x ◃ x = y ◃ y

case mp
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y → x = y

tactic: rfl
state_before: case mpr
R : Type u_1
inst✝ : Rack R
x : R
⊢ x ◃ x = x ◃ x

case mp
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y → x = y

tactic: intro h
state_before: case mp
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y → x = y

tactic: trans (x ◃ x) ◃⁻¹ x ◃ x
state_before: case mp
R : Type u_1
inst✝ : Rack R
x y : R
h : x ◃ x = y ◃ y
⊢ x = y

tactic: rw [← left_cancel (x ◃ x), right_inv, self_act_act_eq]
state_before: R : Type u_1
inst✝ : Rack R
x y : R
h : x ◃ x = y ◃ y
⊢ x = (x ◃ x) ◃⁻¹ x ◃ x

R : Type u_1
inst✝ : Rack R
x y : R
h : x ◃ x = y ◃ y
⊢ (x ◃ x) ◃⁻¹ x ◃ x = y

tactic: rw [h, ← left_cancel (y ◃ y), right_inv, self_act_act_eq]
state_before: R : Type u_1
inst✝ : Rack R
x y : R
h : x ◃ x = y ◃ y
⊢ (x ◃ x) ◃⁻¹ x ◃ x = y
Theorem: Int.lt_add_of_neg_add_lt_right
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.add_comm] at h
state_before: a b c : Int
h : -c + a < b
⊢ a < b + c

tactic: exact Int.lt_add_of_sub_right_lt h
state_before: a b c : Int
h : a + -c < b
⊢ a < b + c
Theorem: MeasureTheory.lintegral_prod_symm
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: simp_rw [← lintegral_prod_swap f hf]
state_before: α : Type u_1
α' : Type ?u.5365024
β : Type u_2
β' : Type ?u.5365030
γ : Type ?u.5365033
E : Type ?u.5365036
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
f : α × β → ℝ≥0∞
hf : AEMeasurable f
⊢ (∫⁻ (z : α × β), f z ∂Measure.prod μ ν) = ∫⁻ (y : β), ∫⁻ (x : α), f (x, y) ∂μ ∂ν

tactic: exact lintegral_prod _ hf.prod_swap
state_before: α : Type u_1
α' : Type ?u.5365024
β : Type u_2
β' : Type ?u.5365030
γ : Type ?u.5365033
E : Type ?u.5365036
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
f : α × β → ℝ≥0∞
hf : AEMeasurable f
⊢ (∫⁻ (z : β × α), f (Prod.swap z) ∂Measure.prod ν μ) = ∫⁻ (y : β), ∫⁻ (x : α), f (x, y) ∂μ ∂ν
Theorem: starConvex_sUnion
File: Mathlib/Analysis/Convex/Star.lean

tactic: rw [sUnion_eq_iUnion]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.8711
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
S : Set (Set E)
hS : ∀ (s : Set E), s ∈ S → StarConvex 𝕜 x s
⊢ StarConvex 𝕜 x (⋃₀ S)

tactic: exact starConvex_iUnion fun s => hS _ s.2
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.8711
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
S : Set (Set E)
hS : ∀ (s : Set E), s ∈ S → StarConvex 𝕜 x s
⊢ StarConvex 𝕜 x (⋃ (i : ↑S), ↑i)
Theorem: PLift.down_injective
File: Mathlib/Logic/Basic.lean

tactic: congr
state_before: α : Sort u_1
a b : α
x✝ : { down := a }.down = { down := b }.down
⊢ { down := a } = { down := b }
Theorem: Cardinal.toNat_add_of_lt_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: apply Cardinal.natCast_injective
state_before: α β : Type u
a : Cardinal
b : Cardinal
ha : a < ℵ₀
hb : b < ℵ₀
⊢ ↑toNat (lift a + lift b) = ↑toNat a + ↑toNat b

tactic: replace ha : lift.{v, u} a < ℵ₀ := by rwa [lift_lt_aleph0]
state_before: case a
α β : Type u
a : Cardinal
b : Cardinal
ha : a < ℵ₀
hb : b < ℵ₀
⊢ ↑(↑toNat (lift a + lift b)) = ↑(↑toNat a + ↑toNat b)

tactic: replace hb : lift.{u, v} b < ℵ₀ := by rwa [lift_lt_aleph0]
state_before: case a
α β : Type u
a : Cardinal
b : Cardinal
hb : b < ℵ₀
ha : lift a < ℵ₀
⊢ ↑(↑toNat (lift a + lift b)) = ↑(↑toNat a + ↑toNat b)

tactic: rw [Nat.cast_add, ← toNat_lift.{v, u} a, ← toNat_lift.{u, v} b, cast_toNat_of_lt_aleph0 ha,
  cast_toNat_of_lt_aleph0 hb, cast_toNat_of_lt_aleph0 (add_lt_aleph0 ha hb)]
state_before: case a
α β : Type u
a : Cardinal
b : Cardinal
ha : lift a < ℵ₀
hb : lift b < ℵ₀
⊢ ↑(↑toNat (lift a + lift b)) = ↑(↑toNat a + ↑toNat b)

tactic: rwa [lift_lt_aleph0]
state_before: α β : Type u
a : Cardinal
b : Cardinal
ha : a < ℵ₀
hb : b < ℵ₀
⊢ lift a < ℵ₀

tactic: rwa [lift_lt_aleph0]
state_before: α β : Type u
a : Cardinal
b : Cardinal
hb : b < ℵ₀
ha : lift a < ℵ₀
⊢ lift b < ℵ₀
Theorem: CategoryTheory.Adjunction.injective_of_map_injective
File: Mathlib/CategoryTheory/Preadditive/Injective.lean

tactic: intro
state_before: C : Type u₁
inst✝³ : Category C
D : Type u_2
inst✝² : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝¹ : Full G
inst✝ : Faithful G
I : D
hI : Injective (G.obj I)
X Y : D
f : X ⟶ I
g : X ⟶ Y
⊢ ∀ [inst : Mono g], ∃ h, g ≫ h = f

tactic: haveI : PreservesLimitsOfSize.{0, 0} G := adj.rightAdjointPreservesLimits
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝² : Full G
inst✝¹ : Faithful G
I : D
hI : Injective (G.obj I)
X Y : D
f : X ⟶ I
g : X ⟶ Y
inst✝ : Mono g
⊢ ∃ h, g ≫ h = f

tactic: rcases hI.factors (G.map f) (G.map g) with ⟨w,h⟩
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝² : Full G
inst✝¹ : Faithful G
I : D
hI : Injective (G.obj I)
X Y : D
f : X ⟶ I
g : X ⟶ Y
inst✝ : Mono g
this : PreservesLimitsOfSize G
⊢ ∃ h, g ≫ h = f

tactic: use inv (adj.counit.app _) ≫ F.map w ≫ adj.counit.app _
state_before: case intro
C : Type u₁
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝² : Full G
inst✝¹ : Faithful G
I : D
hI : Injective (G.obj I)
X Y : D
f : X ⟶ I
g : X ⟶ Y
inst✝ : Mono g
this : PreservesLimitsOfSize G
w : G.obj Y ⟶ G.obj I
h : G.map g ≫ w = G.map f
⊢ ∃ h, g ≫ h = f

tactic: refine' Faithful.map_injective (F := G) _
state_before: case intro
C : Type u₁
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝² : Full G
inst✝¹ : Faithful G
I : D
hI : Injective (G.obj I)
X Y : D
f : X ⟶ I
g : X ⟶ Y
inst✝ : Mono g
this : PreservesLimitsOfSize G
w : G.obj Y ⟶ G.obj I
h : G.map g ≫ w = G.map f
⊢ g ≫ inv (adj.counit.app Y) ≫ F.map w ≫ adj.counit.app I = f

tactic: simpa
state_before: case intro
C : Type u₁
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝² : Full G
inst✝¹ : Faithful G
I : D
hI : Injective (G.obj I)
X Y : D
f : X ⟶ I
g : X ⟶ Y
inst✝ : Mono g
this : PreservesLimitsOfSize G
w : G.obj Y ⟶ G.obj I
h : G.map g ≫ w = G.map f
⊢ G.map (g ≫ inv (adj.counit.app Y) ≫ F.map w ≫ adj.counit.app I) = G.map f
Theorem: Complex.log_neg_I
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp [log]
state_before: ⊢ log (-I) = -(↑π / 2) * I
Theorem: List.lookup_ext
File: Mathlib/Data/List/Sigma.lean

tactic: rw [← mem_dlookup_iff, ← mem_dlookup_iff, h] <;> assumption
state_before: α : Type u
β : α → Type v
l l₁✝ l₂ : List (Sigma β)
inst✝ : DecidableEq α
l₀ l₁ : List (Sigma β)
nd₀ : NodupKeys l₀
nd₁ : NodupKeys l₁
h : ∀ (x : α) (y : β x), y ∈ dlookup x l₀ ↔ y ∈ dlookup x l₁
x✝ : Sigma β
a : α
b : β a
⊢ { fst := a, snd := b } ∈ l₀ ↔ { fst := a, snd := b } ∈ l₁
Theorem: List.all_iff_forall
File: Mathlib/Data/Bool/AllAny.lean

tactic: induction' l with a l ih
state_before: α : Type u_1
p✝ : α → Prop
inst✝ : DecidablePred p✝
l : List α
a : α
p : α → Bool
⊢ all l p = true ↔ ∀ (a : α), a ∈ l → p a = true

tactic: simp only [all_cons, Bool.and_coe_iff, ih, forall_mem_cons]
state_before: case cons
α : Type u_1
p✝ : α → Prop
inst✝ : DecidablePred p✝
l✝ : List α
a✝ : α
p : α → Bool
a : α
l : List α
ih : all l p = true ↔ ∀ (a : α), a ∈ l → p a = true
⊢ all (a :: l) p = true ↔ ∀ (a_1 : α), a_1 ∈ a :: l → p a_1 = true

tactic: exact iff_of_true rfl (forall_mem_nil _)
state_before: case nil
α : Type u_1
p✝ : α → Prop
inst✝ : DecidablePred p✝
l : List α
a : α
p : α → Bool
⊢ all [] p = true ↔ ∀ (a : α), a ∈ [] → p a = true
Theorem: InnerProductGeometry.tan_angle_add_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: by_cases h0 : x = 0
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
⊢ Real.tan (angle x (x + y)) = ‖y‖ / ‖x‖

tactic: rw [angle_add_eq_arctan_of_inner_eq_zero h h0, Real.tan_arctan]
state_before: case neg
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : ¬x = 0
⊢ Real.tan (angle x (x + y)) = ‖y‖ / ‖x‖

tactic: simp [h0]
state_before: case pos
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x = 0
⊢ Real.tan (angle x (x + y)) = ‖y‖ / ‖x‖
Theorem: ENNReal.toReal_sInf
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [ENNReal.toReal, toNNReal_sInf s hf, NNReal.coe_sInf, Set.image_image]
state_before: α : Type ?u.843276
β : Type ?u.843279
a b c d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort ?u.843296
f g : ι → ℝ≥0∞
s : Set ℝ≥0∞
hf : ∀ (r : ℝ≥0∞), r ∈ s → r ≠ ⊤
⊢ ENNReal.toReal (sInf s) = sInf (ENNReal.toReal '' s)
Theorem: Finset.image_image₂_distrib_right
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_3
α' : Type ?u.82976
β : Type u_4
β' : Type u_5
γ : Type u_2
γ' : Type ?u.82988
δ : Type u_1
δ' : Type ?u.82994
ε : Type ?u.82997
ε' : Type ?u.83000
ζ : Type ?u.83003
ζ' : Type ?u.83006
ν : Type ?u.83009
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
g : γ → δ
f' : α → β' → δ
g' : β → β'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' a (g' b)
⊢ ↑(image g (image₂ f s t)) = ↑(image₂ f' s (image g' t))

tactic: exact image_image2_distrib_right h_distrib
state_before: α : Type u_3
α' : Type ?u.82976
β : Type u_4
β' : Type u_5
γ : Type u_2
γ' : Type ?u.82988
δ : Type u_1
δ' : Type ?u.82994
ε : Type ?u.82997
ε' : Type ?u.83000
ζ : Type ?u.83003
ζ' : Type ?u.83006
ν : Type ?u.83009
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
g : γ → δ
f' : α → β' → δ
g' : β → β'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' a (g' b)
⊢ g '' image2 f ↑s ↑t = image2 f' (↑s) (g' '' ↑t)
Theorem: Polynomial.Monic.isPrimitive
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rintro r ⟨q, h⟩
state_before: R : Type u_1
inst✝ : CommSemiring R
p : R[X]
hp : Monic p
⊢ IsPrimitive p

tactic: exact isUnit_of_mul_eq_one r (q.coeff p.natDegree) (by rwa [← coeff_C_mul, ← h])
state_before: case intro
R : Type u_1
inst✝ : CommSemiring R
p : R[X]
hp : Monic p
r : R
q : R[X]
h : p = ↑C r * q
⊢ IsUnit r

tactic: rwa [← coeff_C_mul, ← h]
state_before: R : Type u_1
inst✝ : CommSemiring R
p : R[X]
hp : Monic p
r : R
q : R[X]
h : p = ↑C r * q
⊢ r * coeff q (natDegree p) = 1
Theorem: PosNum.natSize_pos
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases n <;> apply Nat.succ_pos
state_before: α : Type ?u.337158
n : PosNum
⊢ 0 < natSize n