tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.IsFundamentalDomain.measure_fundamentalFrontier
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: simpa only [fundamentalFrontier, iUnion₂_inter, measure_iUnion_null_iff', one_smul,
  measure_iUnion_null_iff, inter_comm s, Function.onFun] using fun g (hg : g ≠ 1) =>
  hs.aedisjoint hg
state_before: G : Type u_2
H : Type ?u.534094
α : Type u_1
β : Type ?u.534100
E : Type ?u.534103
inst✝³ : Countable G
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MeasurableSpace α
μ : Measure α
s : Set α
hs : IsFundamentalDomain G s
⊢ ↑↑μ (fundamentalFrontier G s) = 0
Theorem: Ideal.sup_mul_eq_of_coprime_right
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [mul_comm]
state_before: R : Type u
ι : Type ?u.271655
inst✝ : CommSemiring R
I J K L : Ideal R
h : I ⊔ K = ⊤
⊢ I ⊔ J * K = I ⊔ J

tactic: exact sup_mul_eq_of_coprime_left h
state_before: R : Type u
ι : Type ?u.271655
inst✝ : CommSemiring R
I J K L : Ideal R
h : I ⊔ K = ⊤
⊢ I ⊔ K * J = I ⊔ J
Theorem: isGδ_biUnion
File: Mathlib/Topology/GDelta.lean

tactic: refine' Finite.induction_on hs (by simp) _ h
state_before: α : Type u_2
β : Type ?u.6936
γ : Type ?u.6939
ι : Type u_1
inst✝ : TopologicalSpace α
s : Set ι
hs : Set.Finite s
f : ι → Set α
h : ∀ (i : ι), i ∈ s → IsGδ (f i)
⊢ IsGδ (⋃ (i : ι) (_ : i ∈ s), f i)

tactic: simp only [ball_insert_iff, biUnion_insert]
state_before: α : Type u_2
β : Type ?u.6936
γ : Type ?u.6939
ι : Type u_1
inst✝ : TopologicalSpace α
s : Set ι
hs : Set.Finite s
f : ι → Set α
h : ∀ (i : ι), i ∈ s → IsGδ (f i)
⊢ ∀ {a : ι} {s : Set ι},
    ¬a ∈ s →
      Set.Finite s →
        ((∀ (i : ι), i ∈ s → IsGδ (f i)) → IsGδ (⋃ (i : ι) (_ : i ∈ s), f i)) →
          (∀ (i : ι), i ∈ insert a s → IsGδ (f i)) → IsGδ (⋃ (i : ι) (_ : i ∈ insert a s), f i)

tactic: exact fun _ _ ihs H => H.1.union (ihs H.2)
state_before: α : Type u_2
β : Type ?u.6936
γ : Type ?u.6939
ι : Type u_1
inst✝ : TopologicalSpace α
s : Set ι
hs : Set.Finite s
f : ι → Set α
h : ∀ (i : ι), i ∈ s → IsGδ (f i)
⊢ ∀ {a : ι} {s : Set ι},
    ¬a ∈ s →
      Set.Finite s →
        ((∀ (i : ι), i ∈ s → IsGδ (f i)) → IsGδ (⋃ (i : ι) (_ : i ∈ s), f i)) →
          (IsGδ (f a) ∧ ∀ (i : ι), i ∈ s → IsGδ (f i)) → IsGδ (f a ∪ ⋃ (i : ι) (_ : i ∈ s), f i)

tactic: simp
state_before: α : Type u_2
β : Type ?u.6936
γ : Type ?u.6939
ι : Type u_1
inst✝ : TopologicalSpace α
s : Set ι
hs : Set.Finite s
f : ι → Set α
h : ∀ (i : ι), i ∈ s → IsGδ (f i)
⊢ (∀ (i : ι), i ∈ ∅ → IsGδ (f i)) → IsGδ (⋃ (i : ι) (_ : i ∈ ∅), f i)
Theorem: PowerSeries.coeff_zero_X_mul
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
⊢ ↑(coeff R 0) (X * φ) = 0
Theorem: ENNReal.sub_mul
File: Mathlib/Data/Real/ENNReal.lean

tactic: cases' le_or_lt a b with hab hab
state_before: α : Type ?u.188373
β : Type ?u.188376
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ ⊤
⊢ (a - b) * c = a * c - b * c

tactic: rcases eq_or_lt_of_le (zero_le b) with (rfl | hb)
state_before: case inr
α : Type ?u.188373
β : Type ?u.188376
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ ⊤
hab : b < a
⊢ (a - b) * c = a * c - b * c

tactic: exact (cancel_of_ne <| mul_ne_top hab.ne_top (h hb hab)).tsub_mul
state_before: case inr.inr
α : Type ?u.188373
β : Type ?u.188376
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ ⊤
hab : b < a
hb : 0 < b
⊢ (a - b) * c = a * c - b * c

tactic: simp [hab, mul_right_mono hab]
state_before: case inl
α : Type ?u.188373
β : Type ?u.188376
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ ⊤
hab : a ≤ b
⊢ (a - b) * c = a * c - b * c

tactic: simp
state_before: case inr.inl
α : Type ?u.188373
β : Type ?u.188376
a c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < 0 → 0 < a → c ≠ ⊤
hab : 0 < a
⊢ (a - 0) * c = a * c - 0 * c
Theorem: ZNum.zero_add
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases n <;> rfl
state_before: α : Type ?u.723769
n : ZNum
⊢ 0 + n = n
Theorem: sSup_within_of_ordConnected
File: Mathlib/Order/CompleteLatticeIntervals.lean

tactic: obtain ⟨c, hct⟩ : ∃ c, c ∈ t := ht
state_before: α : Type u_1
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : OrdConnected s
t : Set ↑s
ht : Set.Nonempty t
h_bdd : BddAbove t
⊢ sSup (Subtype.val '' t) ∈ s

tactic: obtain ⟨B, hB⟩ : ∃ B, B ∈ upperBounds t := h_bdd
state_before: case intro
α : Type u_1
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : OrdConnected s
t : Set ↑s
h_bdd : BddAbove t
c : ↑s
hct : c ∈ t
⊢ sSup (Subtype.val '' t) ∈ s

tactic: refine' hs.out c.2 B.2 ⟨_, _⟩
state_before: case intro.intro
α : Type u_1
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : OrdConnected s
t : Set ↑s
c : ↑s
hct : c ∈ t
B : ↑s
hB : B ∈ upperBounds t
⊢ sSup (Subtype.val '' t) ∈ s

tactic: exact (Subtype.mono_coe s).le_csSup_image hct ⟨B, hB⟩
state_before: case intro.intro.refine'_1
α : Type u_1
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : OrdConnected s
t : Set ↑s
c : ↑s
hct : c ∈ t
B : ↑s
hB : B ∈ upperBounds t
⊢ ↑c ≤ sSup (Subtype.val '' t)

tactic: exact (Subtype.mono_coe s).csSup_image_le ⟨c, hct⟩ hB
state_before: case intro.intro.refine'_2
α : Type u_1
s✝ : Set α
inst✝ : ConditionallyCompleteLinearOrder α
s : Set α
hs : OrdConnected s
t : Set ↑s
c : ↑s
hct : c ∈ t
B : ↑s
hB : B ∈ upperBounds t
⊢ sSup (Subtype.val '' t) ≤ ↑B
Theorem: Sigma.nhds_eq
File: Mathlib/Topology/Constructions.lean

tactic: cases x
state_before: α : Type u
β : Type v
γ : Type ?u.527144
δ : Type ?u.527147
ε : Type ?u.527150
ζ : Type ?u.527153
ι : Type u_1
κ : Type ?u.527159
σ : ι → Type u_2
τ : κ → Type ?u.527169
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace α
x : Sigma σ
⊢ 𝓝 x = Filter.map (mk x.fst) (𝓝 x.snd)

tactic: apply Sigma.nhds_mk
state_before: case mk
α : Type u
β : Type v
γ : Type ?u.527144
δ : Type ?u.527147
ε : Type ?u.527150
ζ : Type ?u.527153
ι : Type u_1
κ : Type ?u.527159
σ : ι → Type u_2
τ : κ → Type ?u.527169
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace α
fst✝ : ι
snd✝ : σ fst✝
⊢ 𝓝 { fst := fst✝, snd := snd✝ } = Filter.map (mk { fst := fst✝, snd := snd✝ }.fst) (𝓝 { fst := fst✝, snd := snd✝ }.snd)
Theorem: MeasureTheory.Lp.simpleFunc.toLp_sub
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: simp only [sub_eq_add_neg, ← toLp_neg, ← toLp_add]
state_before: α : Type u_1
β : Type ?u.1507935
ι : Type ?u.1507938
E : Type u_2
F : Type ?u.1507944
𝕜 : Type ?u.1507947
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : α →ₛ E
hf : Memℒp (↑f) p
hg : Memℒp (↑g) p
⊢ toLp (f - g) (_ : Memℒp (↑f - fun a => ↑g a) p) = toLp f hf - toLp g hg
Theorem: ENNReal.trichotomy
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa only [or_iff_not_imp_left] using toReal_pos
state_before: α : Type ?u.828925
β : Type ?u.828928
a b c d : ℝ≥0∞
r p✝ q : ℝ≥0
p : ℝ≥0∞
⊢ p = 0 ∨ p = ⊤ ∨ 0 < ENNReal.toReal p
Theorem: CategoryTheory.Bicategory.inv_whiskerRight
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: aesop_cat_nonterminal
state_before: B : Type u
inst✝¹ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
h : b ⟶ c
inst✝ : IsIso η
⊢ inv (η ▷ h) = inv η ▷ h

tactic: simp only [← comp_whiskerRight, id_whiskerRight, IsIso.hom_inv_id]
state_before: case hom_inv_id
B : Type u
inst : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
h : b ⟶ c
inst_1 : IsIso η
⊢ η ▷ h ≫ inv η ▷ h = 𝟙 (f ≫ h)
Theorem: ZFSet.omega_succ
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: rw [ZFSet.sound h]
state_before: n✝ : ZFSet
x : PSet
x✝ : Quotient.mk setoid x ∈ omega
n : ℕ
h : PSet.Equiv x (Func PSet.omega { down := n })
⊢ insert (mk x) (mk x) = insert (mk (ofNat n)) (mk (ofNat n))

tactic: rfl
state_before: n✝ : ZFSet
x : PSet
x✝ : Quotient.mk setoid x ∈ omega
n : ℕ
h : PSet.Equiv x (Func PSet.omega { down := n })
⊢ insert (mk (Func PSet.omega { down := n })) (mk (Func PSet.omega { down := n })) =
    insert (mk (ofNat n)) (mk (ofNat n))
Theorem: List.mem_bind
File: Std/Data/List/Lemmas.lean

tactic: simp [List.bind, mem_join]
state_before: α : Type u_1
β : Type u_2
f : α → List β
b : β
l : List α
⊢ b ∈ List.bind l f ↔ ∃ a, a ∈ l ∧ b ∈ f a

tactic: exact ⟨fun ⟨_, ⟨a, h₁, rfl⟩, h₂⟩ => ⟨a, h₁, h₂⟩, fun ⟨a, h₁, h₂⟩ => ⟨_, ⟨a, h₁, rfl⟩, h₂⟩⟩
state_before: α : Type u_1
β : Type u_2
f : α → List β
b : β
l : List α
⊢ (∃ l_1, (∃ a, a ∈ l ∧ f a = l_1) ∧ b ∈ l_1) ↔ ∃ a, a ∈ l ∧ b ∈ f a
Theorem: Set.Finite.seq
File: Mathlib/Data/Set/Finite.lean

tactic: classical
  cases hf
  cases hs
  apply toFinite
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
f : Set (α → β)
s : Set α
hf : Set.Finite f
hs : Set.Finite s
⊢ Set.Finite (Set.seq f s)

tactic: cases hf
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
f : Set (α → β)
s : Set α
hf : Set.Finite f
hs : Set.Finite s
⊢ Set.Finite (Set.seq f s)

tactic: cases hs
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
f : Set (α → β)
s : Set α
hs : Set.Finite s
a✝ : Fintype ↑f
⊢ Set.Finite (Set.seq f s)

tactic: apply toFinite
state_before: case intro.intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
f : Set (α → β)
s : Set α
a✝¹ : Fintype ↑f
a✝ : Fintype ↑s
⊢ Set.Finite (Set.seq f s)
Theorem: isOpen_singleton_nhdsAdjoint
File: Mathlib/Topology/Order.lean

tactic: letI := nhdsAdjoint a f
state_before: α✝ : Type u
β : Type v
α : Type u_1
a b : α
f : Filter α
hb : b ≠ a
⊢ IsOpen {b}

tactic: rw [isOpen_singleton_iff_nhds_eq_pure]
state_before: α✝ : Type u
β : Type v
α : Type u_1
a b : α
f : Filter α
hb : b ≠ a
this : TopologicalSpace α := nhdsAdjoint a f
⊢ IsOpen {b}

tactic: exact nhdsAdjoint_nhds_of_ne a f hb
state_before: α✝ : Type u
β : Type v
α : Type u_1
a b : α
f : Filter α
hb : b ≠ a
this : TopologicalSpace α := nhdsAdjoint a f
⊢ 𝓝 b = pure b
Theorem: div_lt_div_of_neg_of_lt
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_eq_mul_one_div a c, div_eq_mul_one_div b c]
state_before: ι : Type ?u.152811
α : Type u_1
β : Type ?u.152817
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c < 0
h : b < a
⊢ a / c < b / c

tactic: exact mul_lt_mul_of_neg_right h (one_div_neg.2 hc)
state_before: ι : Type ?u.152811
α : Type u_1
β : Type ?u.152817
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c < 0
h : b < a
⊢ a * (1 / c) < b * (1 / c)
Theorem: Real.b_ne_one'
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: linarith
state_before: b x y : ℝ
hb : 1 < b
⊢ b ≠ 1
Theorem: Real.exp_one_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← exp_mul, one_mul]
state_before: x : ℝ
⊢ exp 1 ^ x = exp x
Theorem: frontier_Icc
File: Mathlib/Topology/Order/Basic.lean

tactic: simp [frontier, h, Icc_diff_Ioo_same]
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : OrderTopology α
inst✝² : DenselyOrdered α
a✝ b✝ : α
s : Set α
inst✝¹ : NoMinOrder α
inst✝ : NoMaxOrder α
a b : α
h : a ≤ b
⊢ frontier (Icc a b) = {a, b}
Theorem: List.formPerm_rotate
File: Mathlib/GroupTheory/Perm/List.lean

tactic: induction' n with n hn
state_before: α : Type u_1
β : Type ?u.773582
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : Nodup l
n : ℕ
⊢ formPerm (rotate l n) = formPerm l

tactic: simp
state_before: case zero
α : Type u_1
β : Type ?u.773582
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : Nodup l
⊢ formPerm (rotate l Nat.zero) = formPerm l

tactic: rw [Nat.succ_eq_add_one, ← rotate_rotate, formPerm_rotate_one, hn]
state_before: case succ
α : Type u_1
β : Type ?u.773582
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : Nodup l
n : ℕ
hn : formPerm (rotate l n) = formPerm l
⊢ formPerm (rotate l (Nat.succ n)) = formPerm l

tactic: rwa [IsRotated.nodup_iff]
state_before: case succ.h
α : Type u_1
β : Type ?u.773582
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : Nodup l
n : ℕ
hn : formPerm (rotate l n) = formPerm l
⊢ Nodup (rotate l n)

tactic: exact IsRotated.forall l n
state_before: case succ.h
α : Type u_1
β : Type ?u.773582
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : Nodup l
n : ℕ
hn : formPerm (rotate l n) = formPerm l
⊢ rotate l n ~r l
Theorem: Matrix.vecAppend_eq_ite
File: Mathlib/Data/Fin/VecNotation.lean

tactic: ext i
state_before: α✝ : Type u
m n o✝ : ℕ
m' : Type ?u.24888
n' : Type ?u.24891
o' : Type ?u.24894
α : Type u_1
o : ℕ
ho : o = m + n
u : Fin m → α
v : Fin n → α
⊢ vecAppend ho u v = fun i =>
    if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) }

tactic: rw [vecAppend, Fin.append, Function.comp_apply, Fin.addCases]
state_before: case h
α✝ : Type u
m n o✝ : ℕ
m' : Type ?u.24888
n' : Type ?u.24891
o' : Type ?u.24894
α : Type u_1
o : ℕ
ho : o = m + n
u : Fin m → α
v : Fin n → α
i : Fin o
⊢ vecAppend ho u v i = if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) }

tactic: congr with hi
state_before: case h
α✝ : Type u
m n o✝ : ℕ
m' : Type ?u.24888
n' : Type ?u.24891
o' : Type ?u.24894
α : Type u_1
o : ℕ
ho : o = m + n
u : Fin m → α
v : Fin n → α
i : Fin o
⊢ (if hi : ↑(↑(Fin.cast ho) i) < m then
      (_ : ↑(Fin.castAdd n) (Fin.castLT (↑(Fin.cast ho) i) hi) = ↑(Fin.cast ho) i) ▸
        u (Fin.castLT (↑(Fin.cast ho) i) hi)
    else
      (_ :
          ↑(Fin.natAdd m)
              (Fin.subNat m (↑(Fin.cast (_ : m + n = n + m)) (↑(Fin.cast ho) i)) (_ : m ≤ ↑(↑(Fin.cast ho) i))) =
            ↑(Fin.cast ho) i) ▸
        v (Fin.subNat m (↑(Fin.cast (_ : m + n = n + m)) (↑(Fin.cast ho) i)) (_ : m ≤ ↑(↑(Fin.cast ho) i)))) =
    if h : ↑i < m then u { val := ↑i, isLt := h } else v { val := ↑i - m, isLt := (_ : ↑i - m < n) }

tactic: simp only [eq_rec_constant]
state_before: case h.e_e.h
α✝ : Type u
m n o✝ : ℕ
m' : Type ?u.24888
n' : Type ?u.24891
o' : Type ?u.24894
α : Type u_1
o : ℕ
ho : o = m + n
u : Fin m → α
v : Fin n → α
i : Fin o
hi : ¬↑(↑(Fin.cast ho) i) < m
⊢ (_ :
        ↑(Fin.natAdd m)
            (Fin.subNat m (↑(Fin.cast (_ : m + n = n + m)) (↑(Fin.cast ho) i)) (_ : m ≤ ↑(↑(Fin.cast ho) i))) =
          ↑(Fin.cast ho) i) ▸
      v (Fin.subNat m (↑(Fin.cast (_ : m + n = n + m)) (↑(Fin.cast ho) i)) (_ : m ≤ ↑(↑(Fin.cast ho) i))) =
    v { val := ↑i - m, isLt := (_ : ↑i - m < n) }

tactic: rfl
state_before: case h.e_e.h
α✝ : Type u
m n o✝ : ℕ
m' : Type ?u.24888
n' : Type ?u.24891
o' : Type ?u.24894
α : Type u_1
o : ℕ
ho : o = m + n
u : Fin m → α
v : Fin n → α
i : Fin o
hi : ¬↑(↑(Fin.cast ho) i) < m
⊢ v (Fin.subNat m (↑(Fin.cast (_ : m + n = n + m)) (↑(Fin.cast ho) i)) (_ : m ≤ ↑(↑(Fin.cast ho) i))) =
    v { val := ↑i - m, isLt := (_ : ↑i - m < n) }
Theorem: Asymptotics.IsBigOWith.right_le_add_of_lt_1
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: rw [neg_sub, sub_neg_eq_add]
state_before: α : Type u_1
β : Type ?u.664788
E : Type ?u.664791
F : Type ?u.664794
G : Type ?u.664797
E' : Type u_2
F' : Type ?u.664803
G' : Type ?u.664806
E'' : Type ?u.664809
F'' : Type ?u.664812
G'' : Type ?u.664815
R : Type ?u.664818
R' : Type ?u.664821
𝕜 : Type ?u.664824
𝕜' : Type ?u.664827
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f₁ f₂ : α → E'
h : IsBigOWith c l f₁ f₂
hc : c < 1
x : α
⊢ -(-f₂ x - f₁ x) = f₁ x + f₂ x
Theorem: QuadraticForm.PosDef.anisotropic
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: have := hQ _ hx
state_before: S : Type ?u.491077
R : Type ?u.491080
R₁ : Type ?u.491083
M : Type u_1
R₂ : Type u
inst✝² : OrderedRing R₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R₂ M
Q₂ : QuadraticForm R₂ M
n : Type ?u.491349
Q : QuadraticForm R₂ M
hQ : PosDef Q
x : M
hQx : ↑Q x = 0
hx : ¬x = 0
⊢ 0 < 0

tactic: rw [hQx] at this
state_before: S : Type ?u.491077
R : Type ?u.491080
R₁ : Type ?u.491083
M : Type u_1
R₂ : Type u
inst✝² : OrderedRing R₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R₂ M
Q₂ : QuadraticForm R₂ M
n : Type ?u.491349
Q : QuadraticForm R₂ M
hQ : PosDef Q
x : M
hQx : ↑Q x = 0
hx : ¬x = 0
this : 0 < ↑Q x
⊢ 0 < 0

tactic: exact this
state_before: S : Type ?u.491077
R : Type ?u.491080
R₁ : Type ?u.491083
M : Type u_1
R₂ : Type u
inst✝² : OrderedRing R₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R₂ M
Q₂ : QuadraticForm R₂ M
n : Type ?u.491349
Q : QuadraticForm R₂ M
hQ : PosDef Q
x : M
hQx : ↑Q x = 0
hx : ¬x = 0
this : 0 < 0
⊢ 0 < 0
Theorem: TopCat.pullbackIsoProdSubtype_hom_fst
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: rw [← Iso.eq_inv_comp, pullbackIsoProdSubtype_inv_fst]
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackIsoProdSubtype f g).hom ≫ pullbackFst f g = pullback.fst
Theorem: List.range_sublist
File: Std/Data/List/Lemmas.lean

tactic: simp only [range_eq_range', range'_sublist_right]
state_before: m n : Nat
⊢ range m <+ range n ↔ m ≤ n
Theorem: SeminormFamily.basisSets_iff
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: simp only [basisSets, mem_iUnion, mem_singleton_iff]
state_before: 𝕜 : Type u_2
𝕜₂ : Type ?u.8369
𝕝 : Type ?u.8372
𝕝₂ : Type ?u.8375
E : Type u_1
F : Type ?u.8381
G : Type ?u.8384
ι : Type u_3
ι' : Type ?u.8390
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
U : Set E
⊢ U ∈ basisSets p ↔ ∃ i r x, U = ball (Finset.sup i p) 0 r
Theorem: Real.arcsin_of_le_neg_one
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [← arcsin_projIcc, projIcc_of_le_left _ hx, Subtype.coe_mk, arcsin_neg_one]
state_before: x : ℝ
hx : x ≤ -1
⊢ arcsin x = -(π / 2)
Theorem: Int.cast_add
File: Mathlib/Data/Int/Cast/Basic.lean

tactic: simp [← Int.ofNat_add, Nat.cast_add]
state_before: R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(↑m + ↑n) = ↑↑m + ↑↑n

tactic: erw [cast_subNatNat, cast_ofNat, cast_negSucc, sub_eq_add_neg]
state_before: R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(↑m + -[n+1]) = ↑↑m + ↑-[n+1]

tactic: erw [cast_subNatNat, cast_ofNat, cast_negSucc, sub_eq_iff_eq_add, add_assoc,
  eq_neg_add_iff_add_eq, ← Nat.cast_add, ← Nat.cast_add, Nat.add_comm]
state_before: R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(-[m+1] + ↑n) = ↑-[m+1] + ↑↑n

tactic: rw [cast_negSucc, cast_negSucc, cast_negSucc, ← neg_add_rev, ← Nat.cast_add,
  Nat.add_right_comm m n 1, Nat.add_assoc, Nat.add_comm]
state_before: R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑-[m + n + 1+1] = ↑-[m+1] + ↑-[n+1]
Theorem: MeasureTheory.Measure.integral_comp_inv_smul
File: Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean

tactic: rw [integral_comp_smul μ f R⁻¹, inv_pow, inv_inv]
state_before: E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s : Set E
f : E → F
R : ℝ
⊢ (∫ (x : E), f (R⁻¹ • x) ∂μ) = abs (R ^ finrank ℝ E) • ∫ (x : E), f x ∂μ
Theorem: SimpleGraph.chromaticNumber_bot
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: let C : (⊥ : SimpleGraph V).Coloring (Fin 1) :=
    Coloring.mk (fun _ => 0) fun {v w} h => False.elim h
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
inst✝ : Nonempty V
⊢ chromaticNumber ⊥ = 1

tactic: apply le_antisymm
state_before: V : Type u
G : SimpleGraph V
α : Type v
C✝ : Coloring G α
inst✝ : Nonempty V
C : Coloring ⊥ (Fin 1) := Coloring.mk (fun x => 0) (_ : ∀ {v w : V}, Adj ⊥ v w → (fun x => 0) v ≠ (fun x => 0) w)
⊢ chromaticNumber ⊥ = 1

tactic: exact chromaticNumber_le_card C
state_before: case a
V : Type u
G : SimpleGraph V
α : Type v
C✝ : Coloring G α
inst✝ : Nonempty V
C : Coloring ⊥ (Fin 1) := Coloring.mk (fun x => 0) (_ : ∀ {v w : V}, Adj ⊥ v w → (fun x => 0) v ≠ (fun x => 0) w)
⊢ chromaticNumber ⊥ ≤ 1

tactic: exact chromaticNumber_pos C.to_colorable
state_before: case a
V : Type u
G : SimpleGraph V
α : Type v
C✝ : Coloring G α
inst✝ : Nonempty V
C : Coloring ⊥ (Fin 1) := Coloring.mk (fun x => 0) (_ : ∀ {v w : V}, Adj ⊥ v w → (fun x => 0) v ≠ (fun x => 0) w)
⊢ 1 ≤ chromaticNumber ⊥
Theorem: HahnSeries.order_one
File: Mathlib/RingTheory/HahnSeries.lean

tactic: cases' subsingleton_or_nontrivial R with h h <;> haveI := h
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : MulZeroOneClass R
⊢ order 1 = 0

tactic: rw [Subsingleton.elim (1 : HahnSeries Γ R) 0, order_zero]
state_before: case inl
Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : MulZeroOneClass R
h this : Subsingleton R
⊢ order 1 = 0

tactic: exact order_single one_ne_zero
state_before: case inr
Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : MulZeroOneClass R
h this : Nontrivial R
⊢ order 1 = 0
Theorem: ext_inner_left
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← sub_eq_zero, ← @inner_self_eq_zero 𝕜, inner_sub_right, sub_eq_zero, h (x - y)]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1812323
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
h : ∀ (v : E), inner v x = inner v y
⊢ x = y
Theorem: CategoryTheory.Subobject.factorThru_zero
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasZeroMorphisms C
X Y : C
P : Subobject Y
h : Factors P 0
⊢ factorThru P 0 h = 0
Theorem: Finset.erase_inter_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [erase_inter, inter_erase]
state_before: α : Type u_1
β : Type ?u.262881
γ : Type ?u.262884
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b : α
s t : Finset α
a : α
⊢ erase s a ∩ t = s ∩ erase t a
Theorem: CategoryTheory.Functor.biprodComparison'_comp_biprodComparison
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean

tactic: ext <;> simp [← Functor.map_comp]
state_before: C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
F : C ⥤ D
X Y : C
inst✝² : HasBinaryBiproduct X Y
inst✝¹ : HasBinaryBiproduct (F.obj X) (F.obj Y)
inst✝ : PreservesZeroMorphisms F
⊢ biprodComparison' F X Y ≫ biprodComparison F X Y = 𝟙 (F.obj X ⊞ F.obj Y)
Theorem: Cardinal.toNat_eq_one
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [toNat_eq_iff one_ne_zero, Nat.cast_one]
state_before: α β : Type u
c : Cardinal
⊢ ↑toNat c = 1 ↔ c = 1
Theorem: toZ_nonneg
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

tactic: rw [toZ_of_ge hi]
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
hi : i0 ≤ i
⊢ 0 ≤ toZ i0 i

tactic: exact Nat.cast_nonneg _
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
hi : i0 ≤ i
⊢ 0 ≤ ↑(Nat.find (_ : ∃ n, (succ^[n]) i0 = i))