tasksource/leandojo huggingface dataset:
Theorem: CentroidHom.cancel_left
File: Mathlib/Algebra/Hom/Centroid.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.21144
α : Type u_1
inst✝ : NonUnitalNonAssocSemiring α
g f₁ f₂ : CentroidHom α
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: linearIndependent_iff''
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: convert
  H s (fun j => if j ∈ s then g j else 0) (fun j hj => if_neg hj)
    (by simp_rw [ite_smul, zero_smul, Finset.sum_extend_by_zero, hg]) i
state_before: ι : Type u'
ι' : Type ?u.19688
R : Type u_1
K : Type ?u.19694
M : Type u_2
M' : Type ?u.19700
M'' : Type ?u.19703
V : Type u
V' : Type ?u.19708
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
H : ∀ (s : Finset ι) (g : ι → R), (∀ (i : ι), ¬i ∈ s → g i = 0) → ∑ i in s, g i • v i = 0 → ∀ (i : ι), g i = 0
s : Finset ι
g : ι → R
hg : ∑ i in s, g i • v i = 0
i : ι
hi : i ∈ s
⊢ g i = 0

tactic: exact (if_pos hi).symm
state_before: case h.e'_2
ι : Type u'
ι' : Type ?u.19688
R : Type u_1
K : Type ?u.19694
M : Type u_2
M' : Type ?u.19700
M'' : Type ?u.19703
V : Type u
V' : Type ?u.19708
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
H : ∀ (s : Finset ι) (g : ι → R), (∀ (i : ι), ¬i ∈ s → g i = 0) → ∑ i in s, g i • v i = 0 → ∀ (i : ι), g i = 0
s : Finset ι
g : ι → R
hg : ∑ i in s, g i • v i = 0
i : ι
hi : i ∈ s
⊢ g i = if i ∈ s then g i else 0

tactic: simp_rw [ite_smul, zero_smul, Finset.sum_extend_by_zero, hg]
state_before: ι : Type u'
ι' : Type ?u.19688
R : Type u_1
K : Type ?u.19694
M : Type u_2
M' : Type ?u.19700
M'' : Type ?u.19703
V : Type u
V' : Type ?u.19708
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
H : ∀ (s : Finset ι) (g : ι → R), (∀ (i : ι), ¬i ∈ s → g i = 0) → ∑ i in s, g i • v i = 0 → ∀ (i : ι), g i = 0
s : Finset ι
g : ι → R
hg : ∑ i in s, g i • v i = 0
i : ι
hi : i ∈ s
⊢ ∑ i in s, (fun j => if j ∈ s then g j else 0) i • v i = 0
Theorem: Nat.ArithmeticFunction.LSeriesSummable_of_bounded_of_one_lt_re
File: Mathlib/NumberTheory/LSeries.lean

tactic: rw [← LSeriesSummable_iff_of_re_eq_re (Complex.ofReal_re z.re)]
state_before: f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℂ
hz : 1 < z.re
⊢ LSeriesSummable f z

tactic: apply LSeriesSummable_of_bounded_of_one_lt_real h
state_before: f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℂ
hz : 1 < z.re
⊢ LSeriesSummable f ↑z.re

tactic: exact hz
state_before: f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℂ
hz : 1 < z.re
⊢ 1 < z.re
Theorem: Equiv.Perm.dvd_of_mem_cycleType
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: rw [← lcm_cycleType]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
n : ℕ
h : n ∈ cycleType σ
⊢ n ∣ orderOf σ

tactic: exact dvd_lcm h
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
n : ℕ
h : n ∈ cycleType σ
⊢ n ∣ Multiset.lcm (cycleType σ)
Theorem: Nat.WithBot.add_eq_zero_iff
File: Mathlib/Data/Nat/WithBot.lean

tactic: rcases n, m with ⟨_ | _, _ | _⟩
state_before: n m : WithBot ℕ
⊢ n + m = 0 ↔ n = 0 ∧ m = 0

tactic: any_goals (exact ⟨fun h => Option.noConfusion h, fun h => Option.noConfusion h.1⟩)
state_before: case none.none

⊢ none + none = 0 ↔ none = 0 ∧ none = 0

case none.some
val✝ : ℕ
⊢ none + some val✝ = 0 ↔ none = 0 ∧ some val✝ = 0

case some.none
val✝ : ℕ
⊢ some val✝ + none = 0 ↔ some val✝ = 0 ∧ none = 0

case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 0 ↔ some val✝¹ = 0 ∧ some val✝ = 0

tactic: exact ⟨fun h => Option.noConfusion h, fun h => Option.noConfusion h.2⟩
state_before: case some.none
val✝ : ℕ
⊢ some val✝ + none = 0 ↔ some val✝ = 0 ∧ none = 0

case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 0 ↔ some val✝¹ = 0 ∧ some val✝ = 0

tactic: repeat' erw [WithBot.coe_eq_coe]
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 0 ↔ some val✝¹ = 0 ∧ some val✝ = 0

tactic: exact add_eq_zero_iff' (zero_le _) (zero_le _)
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ (fun x x_1 => x + x_1) val✝¹ val✝ = 0 ↔ val✝¹ = 0 ∧ val✝ = 0

tactic: (exact ⟨fun h => Option.noConfusion h, fun h => Option.noConfusion h.1⟩)
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 0 ↔ some val✝¹ = 0 ∧ some val✝ = 0

tactic: exact ⟨fun h => Option.noConfusion h, fun h => Option.noConfusion h.1⟩
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 0 ↔ some val✝¹ = 0 ∧ some val✝ = 0

tactic: erw [WithBot.coe_eq_coe]
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ (fun x x_1 => x + x_1) val✝¹ val✝ = 0 ↔ val✝¹ = 0 ∧ val✝ = 0
Theorem: Valuation.isEquiv_iff_val_sub_one_lt_one
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: rw [isEquiv_iff_val_lt_one]
state_before: K : Type u_3
F : Type ?u.3433435
R : Type ?u.3433438
inst✝³ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type u_2
Γ''₀ : Type ?u.3433450
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : LinearOrderedCommGroupWithZero Γ'₀
v : Valuation K Γ₀
v' : Valuation K Γ'₀
⊢ IsEquiv v v' ↔ ∀ {x : K}, ↑v (x - 1) < 1 ↔ ↑v' (x - 1) < 1

tactic: exact (Equiv.subRight 1).surjective.forall
state_before: K : Type u_3
F : Type ?u.3433435
R : Type ?u.3433438
inst✝³ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type u_2
Γ''₀ : Type ?u.3433450
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : LinearOrderedCommGroupWithZero Γ'₀
v : Valuation K Γ₀
v' : Valuation K Γ'₀
⊢ (∀ {x : K}, ↑v x < 1 ↔ ↑v' x < 1) ↔ ∀ {x : K}, ↑v (x - 1) < 1 ↔ ↑v' (x - 1) < 1
Theorem: pullback_nonzero
File: Mathlib/Algebra/GroupWithZero/Defs.lean

tactic: rw [zero, one]
state_before: G₀ : Type u
M₀ : Type u_2
M₀' : Type u_1
G₀' : Type ?u.9044
inst✝³ : MulZeroOneClass M₀
inst✝² : Nontrivial M₀
a b : M₀
inst✝¹ : Zero M₀'
inst✝ : One M₀'
f : M₀' → M₀
zero : f 0 = 0
one : f 1 = 1
⊢ ¬f 0 = f 1

tactic: exact zero_ne_one
state_before: G₀ : Type u
M₀ : Type u_2
M₀' : Type u_1
G₀' : Type ?u.9044
inst✝³ : MulZeroOneClass M₀
inst✝² : Nontrivial M₀
a b : M₀
inst✝¹ : Zero M₀'
inst✝ : One M₀'
f : M₀' → M₀
zero : f 0 = 0
one : f 1 = 1
⊢ ¬0 = 1
Theorem: Vector.get_replicate
File: Mathlib/Data/Vector/Basic.lean

tactic: apply List.get_replicate
state_before: n : ℕ
α : Type u_1
a : α
i : Fin n
⊢ get (replicate n a) i = a
Theorem: hasSum_geometric_of_lt_1
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: simp_all [neg_inv, geom_sum_eq, div_eq_mul_inv]
state_before: α : Type ?u.68751
β : Type ?u.68754
ι : Type ?u.68757
r : ℝ
h₁ : 0 ≤ r
h₂ : r < 1
this✝ : r ≠ 1
this : Tendsto (fun n => (r ^ n - 1) * (r - 1)⁻¹) atTop (𝓝 ((0 - 1) * (r - 1)⁻¹))
⊢ Tendsto (fun n => ∑ i in Finset.range n, r ^ i) atTop (𝓝 (1 - r)⁻¹)
Theorem: Finset.prod_dvd_prod_of_dvd
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: induction' S using Finset.induction_on' with a T _haS _hTS haT IH
state_before: ι : Type ?u.807675
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
S : Finset α
g1 g2 : α → β
h : ∀ (a : α), a ∈ S → g1 a ∣ g2 a
⊢ Finset.prod S g1 ∣ Finset.prod S g2

tactic: rw [Finset.prod_insert haT, Finset.prod_insert haT]
state_before: case h₂
ι : Type ?u.807675
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝ : CommMonoid β
S : Finset α
g1 g2 : α → β
h✝ : ∀ (a : α), a ∈ S → g1 a ∣ g2 a
a : α
T : Finset α
_haS : a ∈ S
_hTS : T ⊆ S
haT : ¬a ∈ T
IH : (∀ (a : α), a ∈ T → g1 a ∣ g2 a) → Finset.prod T g1 ∣ Finset.prod T g2
h : ∀ (a_1 : α), a_1 ∈ insert a T → g1 a_1 ∣ g2 a_1
⊢ Finset.prod (insert a T) g1 ∣ Finset.prod (insert a T) g2

tactic: exact mul_dvd_mul (h a $ T.mem_insert_self a) (IH fun b hb ↦ h b $ Finset.mem_insert_of_mem hb)
state_before: case h₂
ι : Type ?u.807675
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝ : CommMonoid β
S : Finset α
g1 g2 : α → β
h✝ : ∀ (a : α), a ∈ S → g1 a ∣ g2 a
a : α
T : Finset α
_haS : a ∈ S
_hTS : T ⊆ S
haT : ¬a ∈ T
IH : (∀ (a : α), a ∈ T → g1 a ∣ g2 a) → Finset.prod T g1 ∣ Finset.prod T g2
h : ∀ (a_1 : α), a_1 ∈ insert a T → g1 a_1 ∣ g2 a_1
⊢ g1 a * ∏ x in T, g1 x ∣ g2 a * ∏ x in T, g2 x

tactic: simp
state_before: case h₁
ι : Type ?u.807675
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
S : Finset α
g1 g2 : α → β
h✝ : ∀ (a : α), a ∈ S → g1 a ∣ g2 a
h : ∀ (a : α), a ∈ ∅ → g1 a ∣ g2 a
⊢ Finset.prod ∅ g1 ∣ Finset.prod ∅ g2
Theorem: LinearMap.mulRight_injective
File: Mathlib/Algebra/Algebra/Bilinear.lean

tactic: letI : Nontrivial A := ⟨⟨x, 0, hx⟩⟩
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : NoZeroDivisors A
x : A
hx : x ≠ 0
⊢ Function.Injective ↑(mulRight R x)

tactic: letI := NoZeroDivisors.to_isDomain A
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : NoZeroDivisors A
x : A
hx : x ≠ 0
this : Nontrivial A := { exists_pair_ne := Exists.intro x (Exists.intro 0 hx) }
⊢ Function.Injective ↑(mulRight R x)

tactic: exact mul_left_injective₀ hx
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : NoZeroDivisors A
x : A
hx : x ≠ 0
this✝ : Nontrivial A := { exists_pair_ne := Exists.intro x (Exists.intro 0 hx) }
this : IsDomain A := NoZeroDivisors.to_isDomain A
⊢ Function.Injective ↑(mulRight R x)
Theorem: Finset.card_mul_mul_le_card_mul_mul_card_div
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

tactic: rw [← div_inv_eq_mul, div_eq_mul_inv B]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ card (A * C) * card B ≤ card (A * B) * card (B / C)

tactic: exact card_div_mul_le_card_mul_mul_card_mul _ _ _
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ card (A / C⁻¹) * card B ≤ card (A * B) * card (B * C⁻¹)
Theorem: orderOf_eq_prime_pow
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: apply minimalPeriod_eq_prime_pow <;> rwa [isPeriodicPt_mul_iff_pow_eq_one]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
p : ℕ
hp : Fact (Nat.Prime p)
hnot : ¬x ^ p ^ n = 1
hfin : x ^ p ^ (n + 1) = 1
⊢ orderOf x = p ^ (n + 1)
Theorem: iInf_emptyset
File: Mathlib/Order/CompleteLattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.112728
γ : Type ?u.112731
ι : Sort ?u.112734
ι' : Sort ?u.112737
κ : ι → Sort ?u.112742
κ' : ι' → Sort ?u.112747
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β → α
⊢ (⨅ (x : β) (_ : x ∈ ∅), f x) = ⊤
Theorem: one_div_le
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simpa using inv_le ha hb
state_before: ι : Type ?u.77173
α : Type u_1
β : Type ?u.77179
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
hb : 0 < b
⊢ 1 / a ≤ b ↔ 1 / b ≤ a
Theorem: CategoryTheory.eq_conj_eqToHom
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: simp only [Category.id_comp, eqToHom_refl, Category.comp_id]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
X Y : C
f : X ⟶ Y
⊢ f = eqToHom (_ : X = X) ≫ f ≫ eqToHom (_ : Y = Y)
Theorem: posMulReflectLT_iff_contravariant_pos
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: obtain ha | ha := a.prop.eq_or_lt
state_before: α : Type u_1
a✝ b✝ c✝ d : α
inst✝¹ : MulZeroClass α
inst✝ : PartialOrder α
h✝ : ContravariantClass { x // 0 < x } α (fun x y => ↑x * y) fun x x_1 => x < x_1
a : { x // 0 ≤ x }
b c : α
h : ↑a * b < ↑a * c
⊢ b < c

tactic: simp [←ha] at h
state_before: case inl
α : Type u_1
a✝ b✝ c✝ d : α
inst✝¹ : MulZeroClass α
inst✝ : PartialOrder α
h✝ : ContravariantClass { x // 0 < x } α (fun x y => ↑x * y) fun x x_1 => x < x_1
a : { x // 0 ≤ x }
b c : α
h : ↑a * b < ↑a * c
ha : 0 = ↑a
⊢ b < c
Theorem: FiniteDimensional.finrank_directSum
File: Mathlib/LinearAlgebra/FreeModule/Finite/Rank.lean

tactic: letI := nontrivial_of_invariantBasisNumber R
state_before: R : Type u
M✝ : Type v
N : Type w
inst✝¹⁴ : Ring R
inst✝¹³ : StrongRankCondition R
inst✝¹² : AddCommGroup M✝
inst✝¹¹ : Module R M✝
inst✝¹⁰ : Module.Free R M✝
inst✝⁹ : Module.Finite R M✝
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R N
inst✝⁶ : Module.Free R N
inst✝⁵ : Module.Finite R N
ι : Type v
inst✝⁴ : Fintype ι
M : ι → Type w
inst✝³ : (i : ι) → AddCommGroup (M i)
inst✝² : (i : ι) → Module R (M i)
inst✝¹ : ∀ (i : ι), Module.Free R (M i)
inst✝ : ∀ (i : ι), Module.Finite R (M i)
⊢ finrank R (⨁ (i : ι), M i) = ∑ i : ι, finrank R (M i)

tactic: simp only [finrank, fun i => rank_eq_card_chooseBasisIndex R (M i), rank_directSum, ← mk_sigma,
  mk_toNat_eq_card, card_sigma]
state_before: R : Type u
M✝ : Type v
N : Type w
inst✝¹⁴ : Ring R
inst✝¹³ : StrongRankCondition R
inst✝¹² : AddCommGroup M✝
inst✝¹¹ : Module R M✝
inst✝¹⁰ : Module.Free R M✝
inst✝⁹ : Module.Finite R M✝
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R N
inst✝⁶ : Module.Free R N
inst✝⁵ : Module.Finite R N
ι : Type v
inst✝⁴ : Fintype ι
M : ι → Type w
inst✝³ : (i : ι) → AddCommGroup (M i)
inst✝² : (i : ι) → Module R (M i)
inst✝¹ : ∀ (i : ι), Module.Free R (M i)
inst✝ : ∀ (i : ι), Module.Finite R (M i)
this : Nontrivial R := nontrivial_of_invariantBasisNumber R
⊢ finrank R (⨁ (i : ι), M i) = ∑ i : ι, finrank R (M i)
Theorem: Ordinal.bsup_comp
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← hg]
state_before: α : Type ?u.362805
β : Type ?u.362808
γ : Type ?u.362811
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal
f : (a : Ordinal) → a < o → Ordinal
hf : ∀ {i j : Ordinal} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal) → a < o' → Ordinal
hg : blsub o' g = o
a : Ordinal
ha : a < o'
⊢ g a ha < o

tactic: apply lt_blsub
state_before: α : Type ?u.362805
β : Type ?u.362808
γ : Type ?u.362811
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal
f : (a : Ordinal) → a < o → Ordinal
hf : ∀ {i j : Ordinal} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal) → a < o' → Ordinal
hg : blsub o' g = o
a : Ordinal
ha : a < o'
⊢ g a ha < blsub o' g

tactic: apply le_antisymm <;> refine' bsup_le fun i hi => _
state_before: α : Type ?u.362805
β : Type ?u.362808
γ : Type ?u.362811
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal
f : (a : Ordinal) → a < o → Ordinal
hf : ∀ {i j : Ordinal} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal) → a < o' → Ordinal
hg : blsub o' g = o
⊢ (bsup o' fun a ha => f (g a ha) (_ : g a ha < o)) = bsup o f

tactic: apply le_bsup
state_before: case a
α : Type ?u.362805
β : Type ?u.362808
γ : Type ?u.362811
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal
f : (a : Ordinal) → a < o → Ordinal
hf : ∀ {i j : Ordinal} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal) → a < o' → Ordinal
hg : blsub o' g = o
i : Ordinal
hi : i < o'
⊢ f (g i hi) (_ : g i hi < o) ≤ bsup o f

tactic: rw [← hg, lt_blsub_iff] at hi
state_before: case a
α : Type ?u.362805
β : Type ?u.362808
γ : Type ?u.362811
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal
f : (a : Ordinal) → a < o → Ordinal
hf : ∀ {i j : Ordinal} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal) → a < o' → Ordinal
hg : blsub o' g = o
i : Ordinal
hi : i < o
⊢ f i hi ≤ bsup o' fun a ha => f (g a ha) (_ : g a ha < o)

tactic: rcases hi with ⟨j, hj, hj'⟩
state_before: case a
α : Type ?u.362805
β : Type ?u.362808
γ : Type ?u.362811
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal
f : (a : Ordinal) → a < o → Ordinal
hf : ∀ {i j : Ordinal} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal) → a < o' → Ordinal
hg : blsub o' g = o
i : Ordinal
hi✝ : i < o
hi : ∃ i_1 hi, i ≤ g i_1 hi
⊢ f i hi✝ ≤ bsup o' fun a ha => f (g a ha) (_ : g a ha < o)

tactic: exact (hf _ _ hj').trans (le_bsup _ _ _)
state_before: case a.intro.intro
α : Type ?u.362805
β : Type ?u.362808
γ : Type ?u.362811
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal
f : (a : Ordinal) → a < o → Ordinal
hf : ∀ {i j : Ordinal} (hi : i < o) (hj : j < o), i ≤ j → f i hi ≤ f j hj
g : (a : Ordinal) → a < o' → Ordinal
hg : blsub o' g = o
i : Ordinal
hi : i < o
j : Ordinal
hj : j < o'
hj' : i ≤ g j hj
⊢ f i hi ≤ bsup o' fun a ha => f (g a ha) (_ : g a ha < o)
Theorem: Trivialization.linearMapAt_apply
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: rw [coe_linearMapAt]
state_before: R : Type u_4
B : Type u_1
F : Type u_2
E : B → Type u_3
inst✝⁸ : Semiring R
inst✝⁷ : TopologicalSpace F
inst✝⁶ : TopologicalSpace B
inst✝⁵ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F TotalSpace.proj
x : TotalSpace E
b✝ : B
y✝ : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Trivialization F TotalSpace.proj
inst✝ : Trivialization.IsLinear R e
b : B
y : E b
⊢ ↑(Trivialization.linearMapAt R e b) y = if b ∈ e.baseSet then (↑e (totalSpaceMk b y)).snd else 0
Theorem: Matrix.mul_zero
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.264124
m : Type u_2
n : Type u_1
o : Type u_3
m' : o → Type ?u.264138
n' : o → Type ?u.264143
R : Type ?u.264146
S : Type ?u.264149
α : Type v
β : Type w
γ : Type ?u.264156
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
M : Matrix m n α
⊢ M ⬝ 0 = 0

tactic: apply dotProduct_zero
state_before: case a.h
l : Type ?u.264124
m : Type u_2
n : Type u_1
o : Type u_3
m' : o → Type ?u.264138
n' : o → Type ?u.264143
R : Type ?u.264146
S : Type ?u.264149
α : Type v
β : Type w
γ : Type ?u.264156
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
M : Matrix m n α
i✝ : m
x✝ : o
⊢ (M ⬝ 0) i✝ x✝ = OfNat.ofNat 0 i✝ x✝
Theorem: CategoryTheory.NonPreadditiveAbelian.neg_neg
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [neg_def, neg_def]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ - -a = a

tactic: conv_lhs =>
  congr; rw [← sub_self a]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ 0 - (0 - a) = a

tactic: rw [sub_sub_sub, sub_zero, sub_self, sub_zero]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ a - a - (0 - a) = a
Theorem: Ordinal.lt_one_iff_zero
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simpa using @lt_succ_bot_iff _ _ _ a _ _
state_before: α : Type ?u.180662
β : Type ?u.180665
γ : Type ?u.180668
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal
⊢ a < 1 ↔ a = 0
Theorem: Ctop.Realizer.isOpen
File: Mathlib/Data/Analysis/Topology.lean

tactic: simpa using F.mem_nhds.2 ⟨s, m, Subset.refl _⟩
state_before: α : Type u_1
β : Type ?u.19471
σ : Type ?u.19474
τ : Type ?u.19477
inst✝ : TopologicalSpace α
F : Realizer α
s : F.σ
a : α
m : a ∈ f F.F s
⊢ 𝓝 a ≤ 𝓟 (f F.F s)
Theorem: List.rotate_eq_nil_iff
File: Mathlib/Data/List/Rotate.lean

tactic: induction' n with n hn generalizing l
state_before: α : Type u
l : List α
n : ℕ
⊢ rotate l n = [] ↔ l = []

tactic: simp
state_before: case zero
α : Type u
l✝ l : List α
⊢ rotate l zero = [] ↔ l = []

tactic: cases' l with hd tl
state_before: case succ
α : Type u
l✝ : List α
n : ℕ
hn : ∀ {l : List α}, rotate l n = [] ↔ l = []
l : List α
⊢ rotate l (succ n) = [] ↔ l = []

tactic: simp
state_before: case succ.nil
α : Type u
l : List α
n : ℕ
hn : ∀ {l : List α}, rotate l n = [] ↔ l = []
⊢ rotate [] (succ n) = [] ↔ [] = []

tactic: simp [rotate_cons_succ, hn]
state_before: case succ.cons
α : Type u
l : List α
n : ℕ
hn : ∀ {l : List α}, rotate l n = [] ↔ l = []
hd : α
tl : List α
⊢ rotate (hd :: tl) (succ n) = [] ↔ hd :: tl = []
Theorem: IntermediateField.finiteDimensional_iSup_of_finset'
File: Mathlib/FieldTheory/Adjoin.lean

tactic: haveI : ∀ i : { i // i ∈ s }, FiniteDimensional K (f i) := fun i => h i i.2
state_before: K : Type u_2
L : Type u_3
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
E1 E2 : IntermediateField K L
ι : Type u_1
f : ι → IntermediateField K L
s : Finset ι
h : ∀ (i : ι), i ∈ s → FiniteDimensional K { x // x ∈ f i }
⊢ FiniteDimensional K { x // x ∈ ⨆ (i : ι) (_ : i ∈ s), f i }

tactic: have : (⨆ i ∈ s, f i) = ⨆ i : { i // i ∈ s }, f i :=
  le_antisymm (iSup_le fun i => iSup_le fun h => le_iSup (fun i : { i // i ∈ s } => f i) ⟨i, h⟩)
    (iSup_le fun i => le_iSup_of_le i (le_iSup_of_le i.2 le_rfl))
state_before: K : Type u_2
L : Type u_3
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
E1 E2 : IntermediateField K L
ι : Type u_1
f : ι → IntermediateField K L
s : Finset ι
h : ∀ (i : ι), i ∈ s → FiniteDimensional K { x // x ∈ f i }
this : ∀ (i : { i // i ∈ s }), FiniteDimensional K { x // x ∈ f ↑i }
⊢ FiniteDimensional K { x // x ∈ ⨆ (i : ι) (_ : i ∈ s), f i }

tactic: exact this.symm ▸ IntermediateField.finiteDimensional_iSup_of_finite
state_before: K : Type u_2
L : Type u_3
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
E1 E2 : IntermediateField K L
ι : Type u_1
f : ι → IntermediateField K L
s : Finset ι
h : ∀ (i : ι), i ∈ s → FiniteDimensional K { x // x ∈ f i }
this✝ : ∀ (i : { i // i ∈ s }), FiniteDimensional K { x // x ∈ f ↑i }
this : (⨆ (i : ι) (_ : i ∈ s), f i) = ⨆ (i : { i // i ∈ s }), f ↑i
⊢ FiniteDimensional K { x // x ∈ ⨆ (i : ι) (_ : i ∈ s), f i }
Theorem: Hyperreal.IsSt.unique
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rcases ofSeq_surjective x with ⟨f, rfl⟩
state_before: x : ℝ*
r s : ℝ
hr : IsSt x r
hs : IsSt x s
⊢ r = s

tactic: rw [isSt_ofSeq_iff_tendsto] at hr hs
state_before: case intro
r s : ℝ
f : ℕ → ℝ
hr : IsSt (ofSeq f) r
hs : IsSt (ofSeq f) s
⊢ r = s

tactic: exact tendsto_nhds_unique hr hs
state_before: case intro
r s : ℝ
f : ℕ → ℝ
hr : Tendsto f (↑(hyperfilter ℕ)) (𝓝 r)
hs : Tendsto f (↑(hyperfilter ℕ)) (𝓝 s)
⊢ r = s