tasksource/leandojo huggingface dataset:
Theorem: LinearMap.isSymmetric_iff_isSelfAdjoint
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: rw [isSelfAdjoint_iff', IsSymmetric, ← LinearMap.eq_adjoint_iff]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2211915
G : Type ?u.2211918
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] E
⊢ IsSymmetric A ↔ IsSelfAdjoint A

tactic: exact eq_comm
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2211915
G : Type ?u.2211918
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] E
⊢ A = ↑adjoint A ↔ ↑adjoint A = A
Theorem: AlgebraicTopology.DoldKan.Γ₀.Obj.map_on_summand
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

tactic: dsimp only [SimplicialObject.Splitting.ιSummand, SimplicialObject.Splitting.ιCoprod]
state_before: C : Type u_2
inst✝⁴ : Category C
inst✝³ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ''✝ : SimplexCategory
inst✝² : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
Δ'' : SimplexCategory
e : Δ'.unop ⟶ Δ''
i : Δ'' ⟶ A.fst.unop
inst✝¹ : Epi e
inst✝ : Mono i
fac : e ≫ i = θ.unop ≫ Splitting.IndexSet.e A
⊢ Splitting.ιSummand (splitting K) A ≫ (obj K).map θ =
    Termwise.mapMono K i ≫ Splitting.ιSummand (splitting K) (Splitting.IndexSet.mk e)

tactic: simp only [assoc, Γ₀.splitting_iso_hom_eq_id, id_comp, comp_id]
state_before: C : Type u_2
inst✝⁴ : Category C
inst✝³ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ''✝ : SimplexCategory
inst✝² : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
Δ'' : SimplexCategory
e : Δ'.unop ⟶ Δ''
i : Δ'' ⟶ A.fst.unop
inst✝¹ : Epi e
inst✝ : Mono i
fac : e ≫ i = θ.unop ≫ Splitting.IndexSet.e A
⊢ (Sigma.ι (Splitting.summand (splitting K).N Δ) A ≫ (Splitting.iso (splitting K) Δ).hom) ≫ (obj K).map θ =
    Termwise.mapMono K i ≫
      Sigma.ι (Splitting.summand (splitting K).N Δ'.unop.op) (Splitting.IndexSet.mk e) ≫
        (Splitting.iso (splitting K) Δ'.unop.op).hom

tactic: exact Γ₀.Obj.map_on_summand₀ K A fac
state_before: C : Type u_2
inst✝⁴ : Category C
inst✝³ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ''✝ : SimplexCategory
inst✝² : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
Δ'' : SimplexCategory
e : Δ'.unop ⟶ Δ''
i : Δ'' ⟶ A.fst.unop
inst✝¹ : Epi e
inst✝ : Mono i
fac : e ≫ i = θ.unop ≫ Splitting.IndexSet.e A
⊢ Sigma.ι (Splitting.summand (splitting K).N Δ) A ≫ (obj K).map θ =
    Termwise.mapMono K i ≫ Sigma.ι (Splitting.summand (splitting K).N Δ'.unop.op) (Splitting.IndexSet.mk e)
Theorem: UniqueFactorizationMonoid.multiplicity_eq_count_normalizedFactors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: apply le_antisymm
state_before: α : Type ?u.1033931
R : Type u_1
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : Nontrivial R
inst✝¹ : NormalizationMonoid R
dec_dvd : DecidableRel Dvd.dvd
inst✝ : DecidableEq R
a b : R
ha : Irreducible a
hb : b ≠ 0
⊢ multiplicity a b = ↑(count (↑normalize a) (normalizedFactors b))

tactic: rw [le_multiplicity_iff_replicate_le_normalizedFactors ha hb, ← le_count_iff_replicate_le]
state_before: case a
α : Type ?u.1033931
R : Type u_1
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : Nontrivial R
inst✝¹ : NormalizationMonoid R
dec_dvd : DecidableRel Dvd.dvd
inst✝ : DecidableEq R
a b : R
ha : Irreducible a
hb : b ≠ 0
⊢ ↑(count (↑normalize a) (normalizedFactors b)) ≤ multiplicity a b

tactic: apply PartENat.le_of_lt_add_one
state_before: case a
α : Type ?u.1033931
R : Type u_1
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : Nontrivial R
inst✝¹ : NormalizationMonoid R
dec_dvd : DecidableRel Dvd.dvd
inst✝ : DecidableEq R
a b : R
ha : Irreducible a
hb : b ≠ 0
⊢ multiplicity a b ≤ ↑(count (↑normalize a) (normalizedFactors b))

tactic: rw [← Nat.cast_one, ← Nat.cast_add, lt_iff_not_ge, ge_iff_le,
  le_multiplicity_iff_replicate_le_normalizedFactors ha hb, ← le_count_iff_replicate_le]
state_before: case a.h
α : Type ?u.1033931
R : Type u_1
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : Nontrivial R
inst✝¹ : NormalizationMonoid R
dec_dvd : DecidableRel Dvd.dvd
inst✝ : DecidableEq R
a b : R
ha : Irreducible a
hb : b ≠ 0
⊢ multiplicity a b < ↑(count (↑normalize a) (normalizedFactors b)) + 1

tactic: simp
state_before: case a.h
α : Type ?u.1033931
R : Type u_1
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : Nontrivial R
inst✝¹ : NormalizationMonoid R
dec_dvd : DecidableRel Dvd.dvd
inst✝ : DecidableEq R
a b : R
ha : Irreducible a
hb : b ≠ 0
⊢ ¬count (↑normalize a) (normalizedFactors b) + 1 ≤ count (↑normalize a) (normalizedFactors b)
Theorem: Set.ncard_eq_ncard_iff_ncard_diff_eq_ncard_diff
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [← ncard_inter_add_ncard_diff_eq_ncard s t hs, ← ncard_inter_add_ncard_diff_eq_ncard t s ht,
  inter_comm, add_right_inj]
state_before: α : Type u_1
β : Type ?u.128562
s t : Set α
a b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
ht : autoParam (Set.Finite t) _auto✝
⊢ ncard s = ncard t ↔ ncard (s \ t) = ncard (t \ s)
Theorem: UniformFun.iInf_eq
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: ext : 1
state_before: α : Type u_2
β : Type ?u.37540
γ : Type u_1
ι : Type u_3
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ uniformSpace α γ = ⨅ (i : ι), uniformSpace α γ

tactic: change UniformFun.filter α γ 𝓤[⨅ i, u i] = 𝓤[⨅ i, 𝒰(α, γ, u i)]
state_before: case a
α : Type u_2
β : Type ?u.37540
γ : Type u_1
ι : Type u_3
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ 𝓤 (α →ᵤ γ) = 𝓤 (α →ᵤ γ)

tactic: rw [iInf_uniformity, iInf_uniformity]
state_before: case a
α : Type u_2
β : Type ?u.37540
γ : Type u_1
ι : Type u_3
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ UniformFun.filter α γ (𝓤 γ) = 𝓤 (α →ᵤ γ)

tactic: exact (UniformFun.gc α γ).u_iInf
state_before: case a
α : Type u_2
β : Type ?u.37540
γ : Type u_1
ι : Type u_3
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ UniformFun.filter α γ (⨅ (i : ι), 𝓤 γ) = ⨅ (i : ι), 𝓤 (α →ᵤ γ)
Theorem: prime_two_or_dvd_of_dvd_two_mul_pow_self_two
File: Mathlib/RingTheory/Int/Basic.lean

tactic: cases' Int.Prime.dvd_mul hp h with hp2 hpp
state_before: m : ℤ
p : ℕ
hp : Nat.Prime p
h : ↑p ∣ 2 * m ^ 2
⊢ p = 2 ∨ p ∣ Int.natAbs m

tactic: apply Or.intro_left
state_before: case inl
m : ℤ
p : ℕ
hp : Nat.Prime p
h : ↑p ∣ 2 * m ^ 2
hp2 : p ∣ Int.natAbs 2
⊢ p = 2 ∨ p ∣ Int.natAbs m

tactic: exact le_antisymm (Nat.le_of_dvd zero_lt_two hp2) (Nat.Prime.two_le hp)
state_before: case inl.h
m : ℤ
p : ℕ
hp : Nat.Prime p
h : ↑p ∣ 2 * m ^ 2
hp2 : p ∣ Int.natAbs 2
⊢ p = 2

tactic: apply Or.intro_right
state_before: case inr
m : ℤ
p : ℕ
hp : Nat.Prime p
h : ↑p ∣ 2 * m ^ 2
hpp : p ∣ Int.natAbs (m ^ 2)
⊢ p = 2 ∨ p ∣ Int.natAbs m

tactic: rw [sq, Int.natAbs_mul] at hpp
state_before: case inr.h
m : ℤ
p : ℕ
hp : Nat.Prime p
h : ↑p ∣ 2 * m ^ 2
hpp : p ∣ Int.natAbs (m ^ 2)
⊢ p ∣ Int.natAbs m

tactic: exact (or_self_iff _).mp ((Nat.Prime.dvd_mul hp).mp hpp)
state_before: case inr.h
m : ℤ
p : ℕ
hp : Nat.Prime p
h : ↑p ∣ 2 * m ^ 2
hpp : p ∣ Int.natAbs m * Int.natAbs m
⊢ p ∣ Int.natAbs m
Theorem: Polynomial.Monic.mul
File: Mathlib/Data/Polynomial/Monic.lean

tactic: have : p.leadingCoeff * q.leadingCoeff ≠ 0 := by
  simp [Monic.def.1 hp, Monic.def.1 hq, Ne.symm h0]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
hq : Monic q
h0 : ¬0 = 1
⊢ Monic (p * q)

tactic: rw [Monic.def, leadingCoeff_mul' this, Monic.def.1 hp, Monic.def.1 hq, one_mul]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
hq : Monic q
h0 : ¬0 = 1
this : Polynomial.leadingCoeff p * Polynomial.leadingCoeff q ≠ 0
⊢ Monic (p * q)

tactic: simp [Monic.def.1 hp, Monic.def.1 hq, Ne.symm h0]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
hq : Monic q
h0 : ¬0 = 1
⊢ Polynomial.leadingCoeff p * Polynomial.leadingCoeff q ≠ 0
Theorem: Multiset.stronglyMeasurable_prod'
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: rcases l with ⟨l⟩
state_before: α : Type u_1
β : Type ?u.116204
γ : Type ?u.116207
ι : Type ?u.116210
inst✝³ : Countable ι
f g : α → β
M : Type u_2
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l : Multiset (α → M)
hl : ∀ (f : α → M), f ∈ l → StronglyMeasurable f
⊢ StronglyMeasurable (Multiset.prod l)

tactic: simpa using l.stronglyMeasurable_prod' (by simpa using hl)
state_before: case mk
α : Type u_1
β : Type ?u.116204
γ : Type ?u.116207
ι : Type ?u.116210
inst✝³ : Countable ι
f g : α → β
M : Type u_2
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ (f : α → M), f ∈ Quot.mk Setoid.r l → StronglyMeasurable f
⊢ StronglyMeasurable (Multiset.prod (Quot.mk Setoid.r l))

tactic: simpa using hl
state_before: α : Type u_1
β : Type ?u.116204
γ : Type ?u.116207
ι : Type ?u.116210
inst✝³ : Countable ι
f g : α → β
M : Type u_2
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ (f : α → M), f ∈ Quot.mk Setoid.r l → StronglyMeasurable f
⊢ ∀ (f : α → M), f ∈ l → StronglyMeasurable f
Theorem: compact_basis_nhds
File: Mathlib/Topology/SubsetProperties.lean

tactic: simpa only [and_comm] using LocallyCompactSpace.local_compact_nhds x
state_before: α : Type u
β : Type v
ι : Type ?u.142587
π : ι → Type ?u.142592
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : LocallyCompactSpace α
x : α
⊢ ∀ (t : Set α), t ∈ 𝓝 x → ∃ r, r ∈ 𝓝 x ∧ IsCompact r ∧ r ⊆ t
Theorem: Zsqrtd.norm_eq_zero_iff
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: constructor
state_before: d✝ d : ℤ
hd : d < 0
z : ℤ√d
⊢ norm z = 0 ↔ z = 0

tactic: intro h
state_before: case mp
d✝ d : ℤ
hd : d < 0
z : ℤ√d
⊢ norm z = 0 → z = 0

tactic: rw [ext, zero_re, zero_im]
state_before: case mp
d✝ d : ℤ
hd : d < 0
z : ℤ√d
h : norm z = 0
⊢ z = 0

tactic: rw [norm_def, sub_eq_add_neg, mul_assoc] at h
state_before: case mp
d✝ d : ℤ
hd : d < 0
z : ℤ√d
h : norm z = 0
⊢ z.re = 0 ∧ z.im = 0

tactic: have left := mul_self_nonneg z.re
state_before: case mp
d✝ d : ℤ
hd : d < 0
z : ℤ√d
h : z.re * z.re + -(d * (z.im * z.im)) = 0
⊢ z.re = 0 ∧ z.im = 0

tactic: have right := neg_nonneg.mpr (mul_nonpos_of_nonpos_of_nonneg hd.le (mul_self_nonneg z.im))
state_before: case mp
d✝ d : ℤ
hd : d < 0
z : ℤ√d
h : z.re * z.re + -(d * (z.im * z.im)) = 0
left : 0 ≤ z.re * z.re
⊢ z.re = 0 ∧ z.im = 0

tactic: obtain ⟨ha, hb⟩ := (add_eq_zero_iff' left right).mp h
state_before: case mp
d✝ d : ℤ
hd : d < 0
z : ℤ√d
h : z.re * z.re + -(d * (z.im * z.im)) = 0
left : 0 ≤ z.re * z.re
right : 0 ≤ -(d * (z.im * z.im))
⊢ z.re = 0 ∧ z.im = 0

tactic: constructor <;> apply eq_zero_of_mul_self_eq_zero
state_before: case mp.intro
d✝ d : ℤ
hd : d < 0
z : ℤ√d
h : z.re * z.re + -(d * (z.im * z.im)) = 0
left : 0 ≤ z.re * z.re
right : 0 ≤ -(d * (z.im * z.im))
ha : z.re * z.re = 0
hb : -(d * (z.im * z.im)) = 0
⊢ z.re = 0 ∧ z.im = 0

tactic: exact ha
state_before: case mp.intro.left.h
d✝ d : ℤ
hd : d < 0
z : ℤ√d
h : z.re * z.re + -(d * (z.im * z.im)) = 0
left : 0 ≤ z.re * z.re
right : 0 ≤ -(d * (z.im * z.im))
ha : z.re * z.re = 0
hb : -(d * (z.im * z.im)) = 0
⊢ z.re * z.re = 0

tactic: rw [neg_eq_zero, mul_eq_zero] at hb
state_before: case mp.intro.right.h
d✝ d : ℤ
hd : d < 0
z : ℤ√d
h : z.re * z.re + -(d * (z.im * z.im)) = 0
left : 0 ≤ z.re * z.re
right : 0 ≤ -(d * (z.im * z.im))
ha : z.re * z.re = 0
hb : -(d * (z.im * z.im)) = 0
⊢ z.im * z.im = 0

tactic: exact hb.resolve_left hd.ne
state_before: case mp.intro.right.h
d✝ d : ℤ
hd : d < 0
z : ℤ√d
h : z.re * z.re + -(d * (z.im * z.im)) = 0
left : 0 ≤ z.re * z.re
right : 0 ≤ -(d * (z.im * z.im))
ha : z.re * z.re = 0
hb : d = 0 ∨ z.im * z.im = 0
⊢ z.im * z.im = 0

tactic: rintro rfl
state_before: case mpr
d✝ d : ℤ
hd : d < 0
z : ℤ√d
⊢ z = 0 → norm z = 0

tactic: exact norm_zero
state_before: case mpr
d✝ d : ℤ
hd : d < 0
⊢ norm 0 = 0
Theorem: CauSeq.lt_total
File: Mathlib/Data/Real/CauSeq.lean

tactic: rwa [neg_sub] at h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f g : CauSeq α abs
h✝ : LimZero (g - f) ∨ Pos (-(g - f))
h : Pos (-(g - f))
⊢ g < f
Theorem: Ordinal.bsup_succ_le_blsub
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: refine' ⟨fun h => _, _⟩
state_before: α : Type ?u.354095
β : Type ?u.354098
γ : Type ?u.354101
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
⊢ succ (bsup o f) ≤ blsub o f ↔ ∃ i hi, f i hi = bsup o f

tactic: rintro ⟨_, _, hf⟩
state_before: case refine'_2
α : Type ?u.354095
β : Type ?u.354098
γ : Type ?u.354101
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
⊢ (∃ i hi, f i hi = bsup o f) → succ (bsup o f) ≤ blsub o f

tactic: rw [succ_le_iff, ← hf]
state_before: case refine'_2.intro.intro
α : Type ?u.354095
β : Type ?u.354098
γ : Type ?u.354101
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
w✝¹ : Ordinal
w✝ : w✝¹ < o
hf : f w✝¹ w✝ = bsup o f
⊢ succ (bsup o f) ≤ blsub o f

tactic: exact lt_blsub _ _ _
state_before: case refine'_2.intro.intro
α : Type ?u.354095
β : Type ?u.354098
γ : Type ?u.354101
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
w✝¹ : Ordinal
w✝ : w✝¹ < o
hf : f w✝¹ w✝ = bsup o f
⊢ f w✝¹ w✝ < blsub o f

tactic: by_contra' hf
state_before: case refine'_1
α : Type ?u.354095
β : Type ?u.354098
γ : Type ?u.354101
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
h : succ (bsup o f) ≤ blsub o f
⊢ ∃ i hi, f i hi = bsup o f

tactic: exact
  ne_of_lt (succ_le_iff.1 h)
    (le_antisymm (bsup_le_blsub f) (blsub_le (lt_bsup_of_ne_bsup.1 hf)))
state_before: case refine'_1
α : Type ?u.354095
β : Type ?u.354098
γ : Type ?u.354101
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
h : succ (bsup o f) ≤ blsub o f
hf : ∀ (i : Ordinal) (hi : i < o), f i hi ≠ bsup o f
⊢ False
Theorem: OrderHom.comp_id
File: Mathlib/Order/Hom/Basic.lean

tactic: ext
state_before: F : Type ?u.47398
α : Type u_1
β : Type u_2
γ : Type ?u.47407
δ : Type ?u.47410
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
f : α →o β
⊢ comp f id = f

tactic: rfl
state_before: case h.h
F : Type ?u.47398
α : Type u_1
β : Type u_2
γ : Type ?u.47407
δ : Type ?u.47410
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
f : α →o β
x✝ : α
⊢ ↑(comp f id) x✝ = ↑f x✝
Theorem: frontier_Ioi'
File: Mathlib/Topology/Order/Basic.lean

tactic: simp [frontier, closure_Ioi' ha, Iic_diff_Iio, Icc_self]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b : α
s : Set α
a : α
ha : Set.Nonempty (Ioi a)
⊢ frontier (Ioi a) = {a}
Theorem: EuclideanGeometry.orthogonalProjection_mem_subspace_eq_self
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: ext
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
p : { x // x ∈ s }
⊢ ↑(orthogonalProjection s) ↑p = p

tactic: rw [orthogonalProjection_eq_self_iff]
state_before: case a
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
p : { x // x ∈ s }
⊢ ↑(↑(orthogonalProjection s) ↑p) = ↑p

tactic: exact p.2
state_before: case a
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
p : { x // x ∈ s }
⊢ ↑p ∈ s
Theorem: RingHom.map_mulVec
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp only [Matrix.mulVec, Matrix.map_apply, RingHom.map_dotProduct, Function.comp]
state_before: l : Type ?u.1363005
m : Type u_3
n : Type u_4
o : Type ?u.1363014
m' : o → Type ?u.1363019
n' : o → Type ?u.1363024
R : Type u_1
S : Type u_2
α : Type v
β : Type w
γ : Type ?u.1363037
inst✝⁴ : Fintype n
inst✝³ : NonAssocSemiring α
inst✝² : NonAssocSemiring β
inst✝¹ : NonAssocSemiring R
inst✝ : NonAssocSemiring S
f : R →+* S
M : Matrix m n R
v : n → R
i : m
⊢ ↑f (mulVec M v i) = mulVec (map M ↑f) (↑f ∘ v) i
Theorem: SimpleGraph.Walk.IsCircuit.rotate
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: refine ⟨hc.isTrail.rotate _, ?_⟩
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v : V
c : Walk G v v
hc : IsCircuit c
h : u ∈ support c
⊢ IsCircuit (rotate c h)

tactic: cases c
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v : V
c : Walk G v v
hc : IsCircuit c
h : u ∈ support c
⊢ rotate c h ≠ nil

tactic: exact (hc.ne_nil rfl).elim
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v : V
hc : IsCircuit nil
h : u ∈ support nil
⊢ rotate nil h ≠ nil

tactic: intro hn
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v v✝ : V
h✝ : Adj G v v✝
p✝ : Walk G v✝ v
hc : IsCircuit (cons h✝ p✝)
h : u ∈ support (cons h✝ p✝)
⊢ rotate (cons h✝ p✝) h ≠ nil

tactic: have hn' := congr_arg length hn
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v v✝ : V
h✝ : Adj G v v✝
p✝ : Walk G v✝ v
hc : IsCircuit (cons h✝ p✝)
h : u ∈ support (cons h✝ p✝)
hn : rotate (cons h✝ p✝) h = nil
⊢ False

tactic: rw [rotate, length_append, add_comm, ← length_append, take_spec] at hn'
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v v✝ : V
h✝ : Adj G v v✝
p✝ : Walk G v✝ v
hc : IsCircuit (cons h✝ p✝)
h : u ∈ support (cons h✝ p✝)
hn : rotate (cons h✝ p✝) h = nil
hn' : length (rotate (cons h✝ p✝) h) = length nil
⊢ False

tactic: simp at hn'
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v v✝ : V
h✝ : Adj G v v✝
p✝ : Walk G v✝ v
hc : IsCircuit (cons h✝ p✝)
h : u ∈ support (cons h✝ p✝)
hn : rotate (cons h✝ p✝) h = nil
hn' : length (cons h✝ p✝) = length nil
⊢ False
Theorem: PowerBasis.degree_minpolyGen
File: Mathlib/RingTheory/PowerBasis.lean

tactic: unfold minpolyGen
state_before: R : Type ?u.130887
S : Type u_2
T : Type ?u.130893
inst✝⁹ : CommRing R
inst✝⁸ : Ring S
inst✝⁷ : Algebra R S
A : Type u_1
B : Type ?u.131199
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Algebra A B
K : Type ?u.131621
inst✝² : Field K
inst✝¹ : Algebra A S
inst✝ : Nontrivial A
pb : PowerBasis A S
⊢ degree (minpolyGen pb) = ↑pb.dim

tactic: rw [degree_sub_eq_left_of_degree_lt] <;> rw [degree_X_pow]
state_before: R : Type ?u.130887
S : Type u_2
T : Type ?u.130893
inst✝⁹ : CommRing R
inst✝⁸ : Ring S
inst✝⁷ : Algebra R S
A : Type u_1
B : Type ?u.131199
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Algebra A B
K : Type ?u.131621
inst✝² : Field K
inst✝¹ : Algebra A S
inst✝ : Nontrivial A
pb : PowerBasis A S
⊢ degree (X ^ pb.dim - ∑ i : Fin pb.dim, ↑C (↑(↑pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i) = ↑pb.dim

tactic: apply degree_sum_fin_lt
state_before: R : Type ?u.130887
S : Type u_2
T : Type ?u.130893
inst✝⁹ : CommRing R
inst✝⁸ : Ring S
inst✝⁷ : Algebra R S
A : Type u_1
B : Type ?u.131199
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Algebra A B
K : Type ?u.131621
inst✝² : Field K
inst✝¹ : Algebra A S
inst✝ : Nontrivial A
pb : PowerBasis A S
⊢ degree (∑ i : Fin pb.dim, ↑C (↑(↑pb.basis.repr (pb.gen ^ pb.dim)) i) * X ^ ↑i) < ↑pb.dim
Theorem: MeasureTheory.lintegral_smul_measure
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [lintegral, iSup_subtype', SimpleFunc.lintegral_smul, ENNReal.mul_iSup, smul_eq_mul]
state_before: α : Type u_1
β : Type ?u.905220
γ : Type ?u.905223
δ : Type ?u.905226
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
f : α → ℝ≥0∞
⊢ (∫⁻ (a : α), f a ∂c • μ) = c * ∫⁻ (a : α), f a ∂μ
Theorem: Ordinal.nfpFamily_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [(#ι).lift_id]
state_before: α : Type ?u.33560
r : α → α → Prop
ι : Type u
f : ι → Ordinal → Ordinal
c : Ordinal
hc : ℵ₀ < cof c
hc' : (#ι) < cof c
hf : ∀ (i : ι) (b : Ordinal), b < c → f i b < c
a : Ordinal
⊢ Cardinal.lift (#ι) < cof c
Theorem: BoxIntegral.Prepartition.iUnion_inf
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp only [inf_def, iUnion_biUnion, iUnion_restrict, ← iUnion_inter, ← iUnion_def]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
⊢ Prepartition.iUnion (π₁ ⊓ π₂) = Prepartition.iUnion π₁ ∩ Prepartition.iUnion π₂
Theorem: CategoryTheory.GrothendieckTopology.plusMap_zero
File: Mathlib/CategoryTheory/Sites/Plus.lean

tactic: ext : 2
state_before: C : Type u
inst✝⁴ : Category C
J : GrothendieckTopology C
D : Type w
inst✝³ : Category D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : Preadditive D
P Q : Cᵒᵖ ⥤ D
⊢ plusMap J 0 = 0

tactic: refine' colimit.hom_ext (fun S => _)
state_before: case w.h
C : Type u
inst✝⁴ : Category C
J : GrothendieckTopology C
D : Type w
inst✝³ : Category D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : Preadditive D
P Q : Cᵒᵖ ⥤ D
x✝ : Cᵒᵖ
⊢ (plusMap J 0).app x✝ = 0.app x✝

tactic: erw [comp_zero, colimit.ι_map, J.diagramNatTrans_zero, zero_comp]
state_before: case w.h
C : Type u
inst✝⁴ : Category C
J : GrothendieckTopology C
D : Type w
inst✝³ : Category D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
P✝ : Cᵒᵖ ⥤ D
inst✝¹ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝ : Preadditive D
P Q : Cᵒᵖ ⥤ D
x✝ : Cᵒᵖ
S : (Cover J x✝.unop)ᵒᵖ
⊢ colimit.ι (diagram J P x✝.unop) S ≫ (plusMap J 0).app x✝ = colimit.ι (diagram J P x✝.unop) S ≫ 0.app x✝