tasksource/leandojo huggingface dataset:
Theorem: vectorSpan_eq_span_vsub_set_right
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [vectorSpan_def]
state_before: k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.254707
s : Set P
p : P
hp : p ∈ s
⊢ vectorSpan k s = Submodule.span k ((fun x => x -ᵥ p) '' s)

tactic: refine' le_antisymm _ (Submodule.span_mono _)
state_before: k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.254707
s : Set P
p : P
hp : p ∈ s
⊢ Submodule.span k (s -ᵥ s) = Submodule.span k ((fun x => x -ᵥ p) '' s)

tactic: rw [Submodule.span_le]
state_before: case refine'_1
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.254707
s : Set P
p : P
hp : p ∈ s
⊢ Submodule.span k (s -ᵥ s) ≤ Submodule.span k ((fun x => x -ᵥ p) '' s)

tactic: rintro v ⟨p1, p2, hp1, hp2, hv⟩
state_before: case refine'_1
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.254707
s : Set P
p : P
hp : p ∈ s
⊢ s -ᵥ s ⊆ ↑(Submodule.span k ((fun x => x -ᵥ p) '' s))

tactic: simp_rw [← vsub_sub_vsub_cancel_right p1 p2 p] at hv
state_before: case refine'_1.intro.intro.intro.intro
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.254707
s : Set P
p : P
hp : p ∈ s
v : V
p1 p2 : P
hp1 : p1 ∈ s
hp2 : p2 ∈ s
hv : (fun x x_1 => x -ᵥ x_1) p1 p2 = v
⊢ v ∈ ↑(Submodule.span k ((fun x => x -ᵥ p) '' s))

tactic: rw [← hv, SetLike.mem_coe, Submodule.mem_span]
state_before: case refine'_1.intro.intro.intro.intro
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.254707
s : Set P
p : P
hp : p ∈ s
v : V
p1 p2 : P
hp1 : p1 ∈ s
hp2 : p2 ∈ s
hv : p1 -ᵥ p - (p2 -ᵥ p) = v
⊢ v ∈ ↑(Submodule.span k ((fun x => x -ᵥ p) '' s))

tactic: exact fun m hm => Submodule.sub_mem _ (hm ⟨p1, hp1, rfl⟩) (hm ⟨p2, hp2, rfl⟩)
state_before: case refine'_1.intro.intro.intro.intro
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.254707
s : Set P
p : P
hp : p ∈ s
v : V
p1 p2 : P
hp1 : p1 ∈ s
hp2 : p2 ∈ s
hv : p1 -ᵥ p - (p2 -ᵥ p) = v
⊢ ∀ (p_1 : Submodule k V), (fun x => x -ᵥ p) '' s ⊆ ↑p_1 → p1 -ᵥ p - (p2 -ᵥ p) ∈ p_1

tactic: rintro v ⟨p2, hp2, hv⟩
state_before: case refine'_2
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.254707
s : Set P
p : P
hp : p ∈ s
⊢ (fun x => x -ᵥ p) '' s ⊆ s -ᵥ s

tactic: exact ⟨p2, p, hp2, hp, hv⟩
state_before: case refine'_2.intro.intro
k : Type u_3
V : Type u_2
P : Type u_1
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.254707
s : Set P
p : P
hp : p ∈ s
v : V
p2 : P
hp2 : p2 ∈ s
hv : (fun x => x -ᵥ p) p2 = v
⊢ v ∈ s -ᵥ s
Theorem: iSup₂_eq_bot
File: Mathlib/Order/CompleteLattice.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.88303
β₂ : Type ?u.88306
γ : Type ?u.88309
ι : Sort u_2
ι' : Sort ?u.88315
κ : ι → Sort u_3
κ' : ι' → Sort ?u.88325
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : (i : ι) → κ i → α
⊢ (⨆ (i : ι) (j : κ i), f i j) = ⊥ ↔ ∀ (i : ι) (j : κ i), f i j = ⊥
Theorem: Real.Angle.cos_eq_iff_eq_or_eq_neg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction ψ using Real.Angle.induction_on
state_before: θ ψ : Angle
⊢ cos θ = cos ψ ↔ θ = ψ ∨ θ = -ψ

tactic: exact cos_eq_real_cos_iff_eq_or_eq_neg
state_before: case h
θ : Angle
x✝ : ℝ
⊢ cos θ = cos ↑x✝ ↔ θ = ↑x✝ ∨ θ = -↑x✝
Theorem: CategoryTheory.leftDualIso_id
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ leftDualIso p p = Iso.refl X

tactic: simp only [leftDualIso, Iso.refl_hom, @leftAdjointMate_id _ _ _ _ ⟨X⟩]
state_before: case w
C : Type u₁
inst✝¹ : Category C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ (leftDualIso p p).hom = (Iso.refl X).hom
Theorem: CompositionSeries.mem_toList
File: Mathlib/Order/JordanHolder.lean

tactic: rw [toList, List.mem_ofFn, mem_def]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
x : X
⊢ x ∈ toList s ↔ x ∈ s
Theorem: integrableOn_exp_Iic
File: Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean

tactic: refine'
  integrableOn_Iic_of_intervalIntegral_norm_bounded (exp c) c
    (fun y => intervalIntegrable_exp.1) tendsto_id
    (eventually_of_mem (Iic_mem_atBot 0) fun y _ => _)
state_before: c : ℝ
⊢ IntegrableOn exp (Iic c)

tactic: simp_rw [norm_of_nonneg (exp_pos _).le, integral_exp, sub_le_self_iff]
state_before: c y : ℝ
x✝ : y ∈ Iic 0
⊢ (∫ (x : ℝ) in id y..c, ‖exp x‖) ≤ exp c

tactic: exact (exp_pos _).le
state_before: c y : ℝ
x✝ : y ∈ Iic 0
⊢ 0 ≤ exp (id y)
Theorem: integral_comp_neg_Ioi
File: Mathlib/MeasureTheory/Measure/Lebesgue/Integral.lean

tactic: rw [← neg_neg c, ← integral_comp_neg_Iic]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
c : ℝ
f : ℝ → E
⊢ (∫ (x : ℝ) in Ioi c, f (-x)) = ∫ (x : ℝ) in Iic (-c), f x

tactic: simp only [neg_neg]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
c : ℝ
f : ℝ → E
⊢ (∫ (x : ℝ) in Iic (-c), f (- -x)) = ∫ (x : ℝ) in Iic (- - -c), f x
Theorem: LieSubalgebra.exists_nested_lieIdeal_coe_eq_iff
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: simp only [exists_lieIdeal_coe_eq_iff, coe_bracket, mem_ofLe]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K K' : LieSubalgebra R L
h : K ≤ K'
⊢ (∃ I, ↑R { x // x ∈ K' } I = ofLe h) ↔ ∀ (x y : L), x ∈ K' → y ∈ K → ⁅x, y⁆ ∈ K

tactic: constructor
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K K' : LieSubalgebra R L
h : K ≤ K'
⊢ (∀ (x y : { x // x ∈ K' }), ↑y ∈ K → ⁅↑x, ↑y⁆ ∈ K) ↔ ∀ (x y : L), x ∈ K' → y ∈ K → ⁅x, y⁆ ∈ K

tactic: intro h' x y hx hy
state_before: case mp
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K K' : LieSubalgebra R L
h : K ≤ K'
⊢ (∀ (x y : { x // x ∈ K' }), ↑y ∈ K → ⁅↑x, ↑y⁆ ∈ K) → ∀ (x y : L), x ∈ K' → y ∈ K → ⁅x, y⁆ ∈ K

tactic: exact h' ⟨x, hx⟩ ⟨y, h hy⟩ hy
state_before: case mp
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K K' : LieSubalgebra R L
h : K ≤ K'
h' : ∀ (x y : { x // x ∈ K' }), ↑y ∈ K → ⁅↑x, ↑y⁆ ∈ K
x y : L
hx : x ∈ K'
hy : y ∈ K
⊢ ⁅x, y⁆ ∈ K

tactic: rintro h' ⟨x, hx⟩ ⟨y, hy⟩ hy'
state_before: case mpr
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K K' : LieSubalgebra R L
h : K ≤ K'
⊢ (∀ (x y : L), x ∈ K' → y ∈ K → ⁅x, y⁆ ∈ K) → ∀ (x y : { x // x ∈ K' }), ↑y ∈ K → ⁅↑x, ↑y⁆ ∈ K

tactic: exact h' x y hx hy'
state_before: case mpr.mk.mk
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
K K' : LieSubalgebra R L
h : K ≤ K'
h' : ∀ (x y : L), x ∈ K' → y ∈ K → ⁅x, y⁆ ∈ K
x : L
hx : x ∈ K'
y : L
hy : y ∈ K'
hy' : ↑{ val := y, property := hy } ∈ K
⊢ ⁅↑{ val := x, property := hx }, ↑{ val := y, property := hy }⁆ ∈ K
Theorem: GeneralizedContinuedFraction.continuantsAux_recurrence
File: Mathlib/Algebra/ContinuedFractions/ContinuantsRecurrence.lean

tactic: simp [*, continuantsAux, nextContinuants, nextDenominator, nextNumerator]
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n : ℕ
inst✝ : DivisionRing K
gp ppred pred : Pair K
nth_s_eq : Stream'.Seq.get? g.s n = some gp
nth_conts_aux_eq : continuantsAux g n = ppred
succ_nth_conts_aux_eq : continuantsAux g (n + 1) = pred
⊢ continuantsAux g (n + 2) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }
Theorem: Subgroup.index_map
File: Mathlib/GroupTheory/Index.lean

tactic: rw [← comap_map_eq, index_comap, relindex_mul_index (H.map_le_range f)]
state_before: G : Type u_2
inst✝¹ : Group G
H K L : Subgroup G
G' : Type u_1
inst✝ : Group G'
f : G →* G'
⊢ index (map f H) = index (H ⊔ MonoidHom.ker f) * index (MonoidHom.range f)
Theorem: Multiset.bind_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.37259
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
n : Multiset β
f : α → β → Multiset γ
⊢ (bind 0 fun a => bind n fun b => f a b) = bind n fun b => bind 0 fun a => f a b

tactic: simp (config := { contextual := true })
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.37259
a : α
s t : Multiset α
f✝ g : α → Multiset β
m : Multiset α
n : Multiset β
f : α → β → Multiset γ
⊢ ∀ ⦃a : α⦄ {s : Multiset α},
    ((bind s fun a => bind n fun b => f a b) = bind n fun b => bind s fun a => f a b) →
      (bind (a ::ₘ s) fun a => bind n fun b => f a b) = bind n fun b => bind (a ::ₘ s) fun a => f a b
Theorem: Option.map₂_def
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> rfl
state_before: α✝ : Type ?u.238
β✝ : Type ?u.241
γ✝ : Type ?u.244
f✝ : α✝ → β✝ → γ✝
a✝ : Option α✝
b✝ : Option β✝
c : Option γ✝
α β γ : Type u_1
f : α → β → γ
a : Option α
b : Option β
⊢ map₂ f a b = Seq.seq (f <$> a) fun x => b
Theorem: Filter.pure_prod
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [prod_eq, map_pure, pure_seq_eq_map]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.43728
δ : Type ?u.43731
ι : Sort ?u.43734
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
a : α
f : Filter β
⊢ pure a ×ˢ f = map (Prod.mk a) f
Theorem: Complex.hasSum_cos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Series.lean

tactic: convert Complex.hasSum_cos' z using 1
state_before: z : ℂ
⊢ HasSum (fun n => (-1) ^ n * z ^ (2 * n) / ↑(2 * n)!) (cos z)

tactic: simp_rw [mul_pow, pow_mul, Complex.I_sq, mul_comm]
state_before: case h.e'_5
z : ℂ
⊢ (fun n => (-1) ^ n * z ^ (2 * n) / ↑(2 * n)!) = fun n => (z * I) ^ (2 * n) / ↑(2 * n)!
Theorem: Polynomial.X_mem_lifts
File: Mathlib/Data/Polynomial/Lifts.lean

tactic: simp only [coe_mapRingHom, Set.mem_univ, Subsemiring.coe_top, eq_self_iff_true, map_X,
  and_self_iff]
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f✝ f : R →+* S
⊢ ↑(mapRingHom f) X = X
Theorem: LinearIndependent.to_subtype_range
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: nontriviality R
state_before: ι✝ : Type u'
ι' : Type ?u.240558
R : Type u_2
K : Type ?u.240564
M : Type u_3
M' : Type ?u.240570
M'' : Type ?u.240573
V : Type u
V' : Type ?u.240578
v : ι✝ → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
ι : Type u_1
f : ι → M
hf : LinearIndependent R f
⊢ LinearIndependent R Subtype.val

tactic: exact (linearIndependent_subtype_range hf.injective).2 hf
state_before: ι✝ : Type u'
ι' : Type ?u.240558
R : Type u_2
K : Type ?u.240564
M : Type u_3
M' : Type ?u.240570
M'' : Type ?u.240573
V : Type u
V' : Type ?u.240578
v : ι✝ → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
ι : Type u_1
f : ι → M
hf : LinearIndependent R f
✝ : Nontrivial R
⊢ LinearIndependent R Subtype.val
Theorem: Filter.EventuallyEq.support
File: Mathlib/Order/Filter/IndicatorFunction.lean

tactic: filter_upwards [h]with x hx
state_before: α : Type u_2
β : Type u_1
M : Type ?u.6683
E : Type ?u.6686
inst✝ : Zero β
f g : α → β
l : Filter α
h : f =ᶠ[l] g
⊢ Function.support f =ᶠ[l] Function.support g

tactic: rw [eq_iff_iff]
state_before: case h
α : Type u_2
β : Type u_1
M : Type ?u.6683
E : Type ?u.6686
inst✝ : Zero β
f g : α → β
l : Filter α
h : f =ᶠ[l] g
x : α
hx : f x = g x
⊢ Function.support f x = Function.support g x

tactic: change f x ≠ 0 ↔ g x ≠ 0
state_before: case h
α : Type u_2
β : Type u_1
M : Type ?u.6683
E : Type ?u.6686
inst✝ : Zero β
f g : α → β
l : Filter α
h : f =ᶠ[l] g
x : α
hx : f x = g x
⊢ Function.support f x ↔ Function.support g x

tactic: rw [hx]
state_before: case h
α : Type u_2
β : Type u_1
M : Type ?u.6683
E : Type ?u.6686
inst✝ : Zero β
f g : α → β
l : Filter α
h : f =ᶠ[l] g
x : α
hx : f x = g x
⊢ f x ≠ 0 ↔ g x ≠ 0
Theorem: List.toFinsupp_nil
File: Mathlib/Data/List/ToFinsupp.lean

tactic: ext
state_before: M : Type u_1
inst✝² : Zero M
l : List M
inst✝¹ : DecidablePred fun x => getD l x 0 ≠ 0
n : ℕ
inst✝ : DecidablePred fun i => getD [] i 0 ≠ 0
⊢ toFinsupp [] = 0

tactic: simp
state_before: case h
M : Type u_1
inst✝² : Zero M
l : List M
inst✝¹ : DecidablePred fun x => getD l x 0 ≠ 0
n : ℕ
inst✝ : DecidablePred fun i => getD [] i 0 ≠ 0
a✝ : ℕ
⊢ ↑(toFinsupp []) a✝ = ↑0 a✝
Theorem: SimpleGraph.incidenceSet_inter_incidenceSet_of_adj
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: refine' (G.incidenceSet_inter_incidenceSet_subset <| h.ne).antisymm _
state_before: ι : Sort ?u.100917
𝕜 : Type ?u.100920
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
h : Adj G a b
⊢ incidenceSet G a ∩ incidenceSet G b = {Quotient.mk (Sym2.Rel.setoid V) (a, b)}

tactic: rintro _ (rfl : _ = ⟦(a, b)⟧)
state_before: ι : Sort ?u.100917
𝕜 : Type ?u.100920
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
h : Adj G a b
⊢ {Quotient.mk (Sym2.Rel.setoid V) (a, b)} ⊆ incidenceSet G a ∩ incidenceSet G b

tactic: exact ⟨G.mk'_mem_incidenceSet_left_iff.2 h, G.mk'_mem_incidenceSet_right_iff.2 h⟩
state_before: ι : Sort ?u.100917
𝕜 : Type ?u.100920
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
h : Adj G a b
⊢ Quotient.mk (Sym2.Rel.setoid V) (a, b) ∈ incidenceSet G a ∩ incidenceSet G b
Theorem: Computation.orelse_pure
File: Mathlib/Data/Seq/Computation.lean

tactic: unfold HOrElse.hOrElse instHOrElse
state_before: α : Type u
β : Type v
γ : Type w
c₁ : Computation α
a : α
⊢ destruct (HOrElse.hOrElse (think c₁) fun x => pure a) = Sum.inl a

tactic: unfold OrElse.orElse instOrElse Alternative.orElse instAlternativeComputation
state_before: α : Type u
β : Type v
γ : Type w
c₁ : Computation α
a : α
⊢ destruct ({ hOrElse := fun a b => OrElse.orElse a b }.1 (think c₁) fun x => pure a) = Sum.inl a

tactic: simp [orElse]
state_before: α : Type u
β : Type v
γ : Type w
c₁ : Computation α
a : α
⊢ destruct
      ({
            hOrElse := fun a b =>
              {
                    orElse :=
                      (let src := monad;
                        Alternative.mk empty @orElse).3 }.1
                a b }.1
        (think c₁) fun x => pure a) =
    Sum.inl a
Theorem: Set.Finite.infsep_of_nontrivial
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: simpa
state_before: α : Type ?u.72020
β : Type ?u.72023
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
hsf : Set.Finite s
hs : Set.Nontrivial s
⊢ Finset.Nonempty (Finite.toFinset (_ : Set.Finite (offDiag s)))

tactic: classical simp_rw [hsf.infsep, dif_pos hs]
state_before: α : Type u_1
β : Type ?u.72023
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
hsf : Set.Finite s
hs : Set.Nontrivial s
⊢ Set.infsep s =
    Finset.inf' (Finite.toFinset (_ : Set.Finite (offDiag s)))
      (_ : Finset.Nonempty (Finite.toFinset (_ : Set.Finite (offDiag s)))) (uncurry dist)

tactic: simp_rw [hsf.infsep, dif_pos hs]
state_before: α : Type u_1
β : Type ?u.72023
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
hsf : Set.Finite s
hs : Set.Nontrivial s
⊢ Set.infsep s =
    Finset.inf' (Finite.toFinset (_ : Set.Finite (offDiag s)))
      (_ : Finset.Nonempty (Finite.toFinset (_ : Set.Finite (offDiag s)))) (uncurry dist)
Theorem: IsGreatest.union
File: Mathlib/Order/Bounds/Basic.lean

tactic: cases' le_total a b with h h <;> simp [h, ha.1, hb.1]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t✝ : Set α
a✝ b✝ : α
inst✝ : LinearOrder γ
a b : γ
s t : Set γ
ha : IsGreatest s a
hb : IsGreatest t b
⊢ max a b ∈ s ∪ t
Theorem: Finset.sup'_cons
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← WithBot.coe_eq_coe]
state_before: F : Type ?u.231366
α : Type u_2
β : Type u_1
γ : Type ?u.231375
ι : Type ?u.231378
κ : Type ?u.231381
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
b : β
hb : ¬b ∈ s
h : Finset.Nonempty (cons b s hb)
⊢ sup' (cons b s hb) h f = f b ⊔ sup' s H f

tactic: simp [WithBot.coe_sup]
state_before: F : Type ?u.231366
α : Type u_2
β : Type u_1
γ : Type ?u.231375
ι : Type ?u.231378
κ : Type ?u.231381
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
b : β
hb : ¬b ∈ s
h : Finset.Nonempty (cons b s hb)
⊢ ↑(sup' (cons b s hb) h f) = ↑(f b ⊔ sup' s H f)
Theorem: Complex.arg_neg_eq_arg_add_pi_of_im_neg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rw [arg_of_im_neg hi, arg_of_im_pos (show 0 < (-x).im from Left.neg_pos_iff.2 hi)]
state_before: x : ℂ
hi : x.im < 0
⊢ arg (-x) = arg x + π

tactic: simp [neg_div, Real.arccos_neg, add_comm, ← sub_eq_add_neg]
state_before: x : ℂ
hi : x.im < 0
⊢ arccos ((-x).re / ↑abs (-x)) = -arccos (x.re / ↑abs x) + π
Theorem: CategoryTheory.Limits.biproduct.isoProduct_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: simp [biproduct.isoProduct]
state_before: J : Type w
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : Discrete J
⊢ (isoProduct f).hom ≫ limit.π (Discrete.functor f) j = Pi.lift (π f) ≫ limit.π (Discrete.functor f) j
Theorem: Real.ciSup_const_zero
File: Mathlib/Data/Real/Basic.lean

tactic: cases isEmpty_or_nonempty α
state_before: x y : ℝ
α : Sort u_1
⊢ (⨆ (x : α), 0) = 0

tactic: exact Real.ciSup_empty _
state_before: case inl
x y : ℝ
α : Sort u_1
h✝ : IsEmpty α
⊢ (⨆ (x : α), 0) = 0

tactic: exact ciSup_const
state_before: case inr
x y : ℝ
α : Sort u_1
h✝ : Nonempty α
⊢ (⨆ (x : α), 0) = 0
Theorem: SimpleGraph.adj_iff_exists_edge
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: refine' ⟨fun _ => ⟨G.ne_of_adj ‹_›, ⟦(v, w)⟧, by simpa⟩, _⟩
state_before: ι : Sort ?u.71588
𝕜 : Type ?u.71591
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
G₁ G₂ : SimpleGraph V
v w : V
⊢ Adj G v w ↔ v ≠ w ∧ ∃ e, e ∈ edgeSet G ∧ v ∈ e ∧ w ∈ e

tactic: rintro ⟨hne, e, he, hv⟩
state_before: ι : Sort ?u.71588
𝕜 : Type ?u.71591
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
G₁ G₂ : SimpleGraph V
v w : V
⊢ (v ≠ w ∧ ∃ e, e ∈ edgeSet G ∧ v ∈ e ∧ w ∈ e) → Adj G v w

tactic: rw [Sym2.mem_and_mem_iff hne] at hv
state_before: case intro.intro.intro
ι : Sort ?u.71588
𝕜 : Type ?u.71591
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
G₁ G₂ : SimpleGraph V
v w : V
hne : v ≠ w
e : Sym2 V
he : e ∈ edgeSet G
hv : v ∈ e ∧ w ∈ e
⊢ Adj G v w

tactic: subst e
state_before: case intro.intro.intro
ι : Sort ?u.71588
𝕜 : Type ?u.71591
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
G₁ G₂ : SimpleGraph V
v w : V
hne : v ≠ w
e : Sym2 V
he : e ∈ edgeSet G
hv : e = Quotient.mk (Sym2.Rel.setoid V) (v, w)
⊢ Adj G v w

tactic: rwa [mem_edgeSet] at he
state_before: case intro.intro.intro
ι : Sort ?u.71588
𝕜 : Type ?u.71591
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
G₁ G₂ : SimpleGraph V
v w : V
hne : v ≠ w
he : Quotient.mk (Sym2.Rel.setoid V) (v, w) ∈ edgeSet G
⊢ Adj G v w

tactic: simpa
state_before: ι : Sort ?u.71588
𝕜 : Type ?u.71591
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
G₁ G₂ : SimpleGraph V
v w : V
x✝ : Adj G v w
⊢ Quotient.mk (Sym2.Rel.setoid V) (v, w) ∈ edgeSet G ∧
    v ∈ Quotient.mk (Sym2.Rel.setoid V) (v, w) ∧ w ∈ Quotient.mk (Sym2.Rel.setoid V) (v, w)
Theorem: FractionalIdeal.spanSingleton_mul_inv
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [spanSingleton_inv, spanSingleton_mul_spanSingleton, mul_inv_cancel hx, spanSingleton_one]
state_before: R : Type ?u.52548
A : Type ?u.52551
K : Type u_1
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
inst✝⁷ : IsDomain A
R₁ : Type u_2
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type ?u.53562
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x : K
hx : x ≠ 0
⊢ spanSingleton R₁⁰ x * (spanSingleton R₁⁰ x)⁻¹ = 1
Theorem: PosNum.cast_mul
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_nat, mul_to_nat, Nat.cast_mul, cast_to_nat, cast_to_nat]
state_before: α : Type u_1
inst✝ : Semiring α
m n : PosNum
⊢ ↑(m * n) = ↑m * ↑n
Theorem: CircleDeg1Lift.exists_eq_add_translationNumber
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: obtain ⟨a, ha⟩ : ∃ x, f x ≤ x + τ f := by
  by_contra' H
  exact lt_irrefl _ (f.lt_translationNumber_of_forall_add_lt hf H)
state_before: f g : CircleDeg1Lift
hf : Continuous ↑f
⊢ ∃ x, ↑f x = x + τ f

tactic: obtain ⟨b, hb⟩ : ∃ x, x + τ f ≤ f x := by
  by_contra' H
  exact lt_irrefl _ (f.translationNumber_lt_of_forall_lt_add hf H)
state_before: case intro
f g : CircleDeg1Lift
hf : Continuous ↑f
a : ℝ
ha : ↑f a ≤ a + τ f
⊢ ∃ x, ↑f x = x + τ f

tactic: exact intermediate_value_univ₂ hf (continuous_id.add continuous_const) ha hb
state_before: case intro.intro
f g : CircleDeg1Lift
hf : Continuous ↑f
a : ℝ
ha : ↑f a ≤ a + τ f
b : ℝ
hb : b + τ f ≤ ↑f b
⊢ ∃ x, ↑f x = x + τ f

tactic: by_contra' H
state_before: f g : CircleDeg1Lift
hf : Continuous ↑f
⊢ ∃ x, ↑f x ≤ x + τ f

tactic: exact lt_irrefl _ (f.lt_translationNumber_of_forall_add_lt hf H)
state_before: f g : CircleDeg1Lift
hf : Continuous ↑f
H : ∀ (x : ℝ), x + τ f < ↑f x
⊢ False

tactic: by_contra' H
state_before: f g : CircleDeg1Lift
hf : Continuous ↑f
a : ℝ
ha : ↑f a ≤ a + τ f
⊢ ∃ x, x + τ f ≤ ↑f x

tactic: exact lt_irrefl _ (f.translationNumber_lt_of_forall_lt_add hf H)
state_before: f g : CircleDeg1Lift
hf : Continuous ↑f
a : ℝ
ha : ↑f a ≤ a + τ f
H : ∀ (x : ℝ), ↑f x < x + τ f
⊢ False
Theorem: IsSeparable.of_algHom
File: Mathlib/FieldTheory/Separable.lean

tactic: letI : Algebra E E' := RingHom.toAlgebra f.toRingHom
state_before: F : Type u_2
K : Type ?u.1131825
E : Type u_3
inst✝⁹ : Field F
inst✝⁸ : Field K
inst✝⁷ : Field E
inst✝⁶ : Algebra F K
inst✝⁵ : Algebra F E
inst✝⁴ : Algebra K E
inst✝³ : IsScalarTower F K E
E' : Type u_1
inst✝² : Field E'
inst✝¹ : Algebra F E'
f : E →ₐ[F] E'
inst✝ : IsSeparable F E'
⊢ IsSeparable F E

tactic: haveI : IsScalarTower F E E' := IsScalarTower.of_algebraMap_eq fun x => (f.commutes x).symm
state_before: F : Type u_2
K : Type ?u.1131825
E : Type u_3
inst✝⁹ : Field F
inst✝⁸ : Field K
inst✝⁷ : Field E
inst✝⁶ : Algebra F K
inst✝⁵ : Algebra F E
inst✝⁴ : Algebra K E
inst✝³ : IsScalarTower F K E
E' : Type u_1
inst✝² : Field E'
inst✝¹ : Algebra F E'
f : E →ₐ[F] E'
inst✝ : IsSeparable F E'
this : Algebra E E' := RingHom.toAlgebra ↑f
⊢ IsSeparable F E

tactic: exact isSeparable_tower_bot_of_isSeparable F E E'
state_before: F : Type u_2
K : Type ?u.1131825
E : Type u_3
inst✝⁹ : Field F
inst✝⁸ : Field K
inst✝⁷ : Field E
inst✝⁶ : Algebra F K
inst✝⁵ : Algebra F E
inst✝⁴ : Algebra K E
inst✝³ : IsScalarTower F K E
E' : Type u_1
inst✝² : Field E'
inst✝¹ : Algebra F E'
f : E →ₐ[F] E'
inst✝ : IsSeparable F E'
this✝ : Algebra E E' := RingHom.toAlgebra ↑f
this : IsScalarTower F E E'
⊢ IsSeparable F E