tasksource/leandojo huggingface dataset:
Theorem: MvPowerSeries.monomial_mul_monomial
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: ext k
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
a b : R
⊢ ↑(monomial R m) a * ↑(monomial R n) b = ↑(monomial R (m + n)) (a * b)

tactic: simp only [coeff_mul_monomial, coeff_monomial]
state_before: case h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
a b : R
k : σ →₀ ℕ
⊢ ↑(coeff R k) (↑(monomial R m) a * ↑(monomial R n) b) = ↑(coeff R k) (↑(monomial R (m + n)) (a * b))

tactic: split_ifs with h₁ h₂ h₃ h₃ h₂ <;> try rfl
state_before: case h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
a b : R
k : σ →₀ ℕ
⊢ (if n ≤ k then (if k - n = m then a else 0) * b else 0) = if k = m + n then a * b else 0

tactic: rfl
state_before: case h.inr.inr
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
a b : R
k : σ →₀ ℕ
h₁ : ¬n ≤ k
h₂ : ¬k = m + n
⊢ 0 = 0

tactic: rw [← h₂, tsub_add_cancel_of_le h₁] at h₃
state_before: case h.inl.inl.inr
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
a b : R
k : σ →₀ ℕ
h₁ : n ≤ k
h₂ : k - n = m
h₃ : ¬k = m + n
⊢ a * b = 0

tactic: exact (h₃ rfl).elim
state_before: case h.inl.inl.inr
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
a b : R
k : σ →₀ ℕ
h₁ : n ≤ k
h₂ : k - n = m
h₃ : ¬k = k
⊢ a * b = 0

tactic: rw [h₃, add_tsub_cancel_right] at h₂
state_before: case h.inl.inr.inl
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
a b : R
k : σ →₀ ℕ
h₁ : n ≤ k
h₂ : ¬k - n = m
h₃ : k = m + n
⊢ 0 * b = a * b

tactic: exact (h₂ rfl).elim
state_before: case h.inl.inr.inl
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
a b : R
k : σ →₀ ℕ
h₁ : n ≤ k
h₂ : ¬m = m
h₃ : k = m + n
⊢ 0 * b = a * b

tactic: exact MulZeroClass.zero_mul b
state_before: case h.inl.inr.inr
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
a b : R
k : σ →₀ ℕ
h₁ : n ≤ k
h₂ : ¬k - n = m
h₃ : ¬k = m + n
⊢ 0 * b = 0

tactic: rw [h₂] at h₁
state_before: case h.inr.inl
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
a b : R
k : σ →₀ ℕ
h₁ : ¬n ≤ k
h₂ : k = m + n
⊢ 0 = a * b

tactic: exact (h₁ <| le_add_left le_rfl).elim
state_before: case h.inr.inl
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
a b : R
k : σ →₀ ℕ
h₁ : ¬n ≤ m + n
h₂ : k = m + n
⊢ 0 = a * b
Theorem: List.Duplicate.mono_sublist
File: Mathlib/Data/List/Duplicate.lean

tactic: induction' h with l₁ l₂ y _ IH l₁ l₂ y h IH
state_before: α : Type u_1
l : List α
x : α
l' : List α
hx : x ∈+ l
h : l <+ l'
⊢ x ∈+ l'

tactic: exact hx
state_before: case slnil
α : Type u_1
l : List α
x : α
l' : List α
hx✝ : x ∈+ l
hx : x ∈+ []
⊢ x ∈+ []

tactic: exact (IH hx).duplicate_cons _
state_before: case cons
α : Type u_1
l : List α
x : α
l' : List α
hx✝ : x ∈+ l
l₁ l₂ : List α
y : α
a✝ : l₁ <+ l₂
IH : x ∈+ l₁ → x ∈+ l₂
hx : x ∈+ l₁
⊢ x ∈+ y :: l₂

tactic: rw [duplicate_cons_iff] at hx⊢
state_before: case cons₂
α : Type u_1
l : List α
x : α
l' : List α
hx✝ : x ∈+ l
l₁ l₂ : List α
y : α
h : l₁ <+ l₂
IH : x ∈+ l₁ → x ∈+ l₂
hx : x ∈+ y :: l₁
⊢ x ∈+ y :: l₂

tactic: rcases hx with (⟨rfl, hx⟩ | hx)
state_before: case cons₂
α : Type u_1
l : List α
x : α
l' : List α
hx✝ : x ∈+ l
l₁ l₂ : List α
y : α
h : l₁ <+ l₂
IH : x ∈+ l₁ → x ∈+ l₂
hx : y = x ∧ x ∈ l₁ ∨ x ∈+ l₁
⊢ y = x ∧ x ∈ l₂ ∨ x ∈+ l₂

tactic: simp [h.subset hx]
state_before: case cons₂.inl.intro
α : Type u_1
l l' l₁ l₂ : List α
y : α
h : l₁ <+ l₂
hx✝ : y ∈+ l
IH : y ∈+ l₁ → y ∈+ l₂
hx : y ∈ l₁
⊢ y = y ∧ y ∈ l₂ ∨ y ∈+ l₂

tactic: simp [IH hx]
state_before: case cons₂.inr
α : Type u_1
l : List α
x : α
l' : List α
hx✝ : x ∈+ l
l₁ l₂ : List α
y : α
h : l₁ <+ l₂
IH : x ∈+ l₁ → x ∈+ l₂
hx : x ∈+ l₁
⊢ y = x ∧ x ∈ l₂ ∨ x ∈+ l₂
Theorem: inv_div'
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.30365
G : Type ?u.30368
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ (a / b)⁻¹ = a⁻¹ / b⁻¹
Theorem: Ordinal.type_out
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [Ordinal.type, WellOrder.eta, Quotient.out_eq]
state_before: α : Type ?u.23296
β : Type ?u.23299
γ : Type ?u.23302
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
⊢ type (Quotient.out o).r = o
Theorem: List.filter_true
File: Mathlib/Data/List/Basic.lean

tactic: induction l <;> simp [*, filter]
state_before: ι : Type ?u.380943
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
⊢ filter (fun x => true) l = l
Theorem: PFun.coe_comp
File: Mathlib/Data/PFun.lean

tactic: simp only [coe_val, comp_apply, Function.comp, Part.bind_some]
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.59817
ε : Type ?u.59820
ι : Type ?u.59823
f✝ : α →. β
g : β → γ
f : α → β
x✝¹ : α
x✝ : γ
⊢ x✝ ∈ ↑(g ∘ f) x✝¹ ↔ x✝ ∈ comp (↑g) (↑f) x✝¹
Theorem: Function.Periodic.eq
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [zero_add] using h 0
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.108782
f g : α → β
c c₁ c₂ x : α
inst✝ : AddZeroClass α
h : Periodic f c
⊢ f c = f 0
Theorem: Mathlib.Tactic.Ring.mul_congr
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a a' b b' c : R
x✝² : a = a'
x✝¹ : b = b'
x✝ : a' * b' = c
⊢ a * b = c

tactic: rfl
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a' b' : R
⊢ a' * b' = a' * b'
Theorem: Real.le_log_iff_exp_le
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [← exp_le_exp, exp_log hy]
state_before: x y : ℝ
hy : 0 < y
⊢ x ≤ log y ↔ exp x ≤ y
Theorem: CategoryTheory.comp_eqToHom_iff
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: simp
state_before: C : Type u₁
inst✝ : Category C
X Y Y' : C
p : Y = Y'
f : X ⟶ Y
g : X ⟶ Y'
h : f ≫ eqToHom p = g
⊢ f = (f ≫ eqToHom p) ≫ eqToHom (_ : Y' = Y)

tactic: simp [eq_whisker h (eqToHom p)]
state_before: C : Type u₁
inst✝ : Category C
X Y Y' : C
p : Y = Y'
f : X ⟶ Y
g : X ⟶ Y'
h : f = g ≫ eqToHom (_ : Y' = Y)
⊢ f ≫ eqToHom p = g
Theorem: List.removeNth_insertNth
File: Mathlib/Data/List/Basic.lean

tactic: rw [removeNth_eq_nth_tail, insertNth, modifyNthTail_modifyNthTail_same]
state_before: ι : Type ?u.113196
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
n : ℕ
l : List α
⊢ removeNth (insertNth n a l) n = l

tactic: exact modifyNthTail_id _ _
state_before: ι : Type ?u.113196
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
n : ℕ
l : List α
⊢ modifyNthTail (tail ∘ cons a) n l = l
Theorem: Real.Angle.neg_coe_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← coe_neg, angle_eq_iff_two_pi_dvd_sub]
state_before: ⊢ -↑π = ↑π

tactic: use -1
state_before: ⊢ ∃ k, -π - π = 2 * π * ↑k

tactic: simp [two_mul, sub_eq_add_neg]
state_before: ⊢ -π - π = 2 * π * ↑(-1)
Theorem: Finset.disjoint_singleton_left
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [disjoint_left, mem_singleton, forall_eq]
state_before: α : Type u_1
β : Type ?u.69965
γ : Type ?u.69968
f : α → β
s t u : Finset α
a b : α
⊢ _root_.Disjoint {a} s ↔ ¬a ∈ s
Theorem: PGame.add_moveRight_inr
File: Mathlib/SetTheory/Game/PGame.lean

tactic: cases x
state_before: x y : PGame
i : RightMoves y
⊢ moveRight (x + y) (↑toRightMovesAdd (Sum.inr i)) = x + moveRight y i

tactic: cases y
state_before: case mk
y : PGame
i : RightMoves y
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ moveRight (mk α✝ β✝ a✝¹ a✝ + y) (↑toRightMovesAdd (Sum.inr i)) = mk α✝ β✝ a✝¹ a✝ + moveRight y i

tactic: rfl
state_before: case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : RightMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveRight (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝) (↑toRightMovesAdd (Sum.inr i)) =
    mk α✝¹ β✝¹ a✝³ a✝² + moveRight (mk α✝ β✝ a✝¹ a✝) i
Theorem: norm_injOn_ray_right
File: Mathlib/Analysis/NormedSpace/Ray.lean

tactic: simpa only [SameRay.sameRay_comm] using norm_injOn_ray_left hy
state_before: E : Type ?u.122924
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : F
hy : y ≠ 0
⊢ Set.InjOn Norm.norm {x | SameRay ℝ x y}
Theorem: Polynomial.not_isUnit_X_pow_sub_one
File: Mathlib/Data/Polynomial/Monic.lean

tactic: intro h
state_before: R✝ : Type u
S : Type v
a b : R✝
m n✝ : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
n : ℕ
⊢ ¬IsUnit (X ^ n - 1)

tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: R✝ : Type u
S : Type v
a b : R✝
m n✝ : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
n : ℕ
h : IsUnit (X ^ n - 1)
⊢ False

tactic: apply hn
state_before: case inr
R✝ : Type u
S : Type v
a b : R✝
m n✝ : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
n : ℕ
h : IsUnit (X ^ n - 1)
hn : n ≠ 0
⊢ False

tactic: rw [← @natDegree_one R, ← (monic_X_pow_sub_C _ hn).eq_one_of_isUnit h, natDegree_X_pow_sub_C]
state_before: case inr
R✝ : Type u
S : Type v
a b : R✝
m n✝ : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
n : ℕ
h : IsUnit (X ^ n - 1)
hn : n ≠ 0
⊢ n = 0

tactic: simp at h
state_before: case inl
R✝ : Type u
S : Type v
a b : R✝
m n : ℕ
ι : Type y
inst✝² : Ring R✝
p : R✝[X]
R : Type u_1
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h : IsUnit (X ^ 0 - 1)
⊢ False
Theorem: separated_def
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: simp only [separatedSpace_iff, Set.ext_iff, Prod.forall, mem_idRel, separationRel, mem_sInter]
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
⊢ SeparatedSpace α ↔ ∀ (x y : α), (∀ (r : Set (α × α)), r ∈ 𝓤 α → (x, y) ∈ r) → x = y

tactic: exact forall₂_congr fun _ _ => ⟨Iff.mp, fun h => ⟨h, fun H U hU => H ▸ refl_mem_uniformity hU⟩⟩
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
⊢ (∀ (a b : α), (∀ (t : Set (α × α)), t ∈ (𝓤 α).sets → (a, b) ∈ t) ↔ a = b) ↔
    ∀ (x y : α), (∀ (r : Set (α × α)), r ∈ 𝓤 α → (x, y) ∈ r) → x = y
Theorem: RingHom.fieldRange_eq_map
File: Mathlib/FieldTheory/Subfield.lean

tactic: ext
state_before: K : Type u
L : Type v
M : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field M
g : L →+* M
f : K →+* L
⊢ fieldRange f = Subfield.map f ⊤

tactic: simp
state_before: case h
K : Type u
L : Type v
M : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field M
g : L →+* M
f : K →+* L
x✝ : L
⊢ x✝ ∈ fieldRange f ↔ x✝ ∈ Subfield.map f ⊤
Theorem: MonoidAlgebra.mul_single_one_apply
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [mul_one]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.504877
inst✝¹ : Semiring k
inst✝ : MulOneClass G
f : MonoidAlgebra k G
r : k
x a : G
⊢ a * 1 = x ↔ a = x
Theorem: CategoryTheory.Limits.PullbackCone.mono_fst_of_is_pullback_of_mono
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: refine ⟨fun {W} h k i => IsLimit.hom_ext ht i ?_⟩
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
⊢ Mono (fst t)

tactic: rw [← cancel_mono g, Category.assoc, Category.assoc, ←condition]
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ fst t = k ≫ fst t
⊢ h ≫ snd t = k ≫ snd t

tactic: dsimp at this
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ fst t = k ≫ fst t
this : (fun x => x ≫ f) (h ≫ fst t) = (fun x => x ≫ f) (k ≫ fst t)
⊢ h ≫ fst t ≫ f = k ≫ fst t ≫ f

tactic: rwa [Category.assoc, Category.assoc] at this
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
ht : IsLimit t
inst✝ : Mono g
W : C
h k : W ⟶ t.pt
i : h ≫ fst t = k ≫ fst t
this : (h ≫ fst t) ≫ f = (k ≫ fst t) ≫ f
⊢ h ≫ fst t ≫ f = k ≫ fst t ≫ f
Theorem: Bool.left_le_or
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (x y : Bool), x ≤ (x || y)
Theorem: sbtw_iff_right_ne_and_left_mem_image_Ioi
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [sbtw_comm, sbtw_iff_left_ne_and_right_mem_image_Ioi]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.511588
P : Type u_3
P' : Type ?u.511594
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y z : P
⊢ Sbtw R x y z ↔ z ≠ y ∧ x ∈ ↑(lineMap z y) '' Set.Ioi 1
Theorem: CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_left
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: rw [← Equiv.eq_symm_apply]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ ↑(homEquiv adj X' Y) (F.map f ≫ g) = f ≫ ↑(homEquiv adj X Y) g

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = ↑(homEquiv adj X' Y).symm (f ≫ ↑(homEquiv adj X Y) g)
Theorem: Computable.option_getD
File: Mathlib/Computability/Partrec.lean

tactic: cases f a <;> rfl
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.191844
σ : Type ?u.191847
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
g : α → β
hf : Computable f
hg : Computable g
a : α
⊢ (Option.casesOn (f a) (g a) fun b => b) = Option.getD (f a) (g a)
Theorem: IsIdempotentElem.one_sub
File: Mathlib/Algebra/Ring/Idempotents.lean

tactic: rw [IsIdempotentElem, mul_sub, mul_one, sub_mul, one_mul, h.eq, sub_self, sub_zero]
state_before: M : Type ?u.2741
N : Type ?u.2744
S : Type ?u.2747
M₀ : Type ?u.2750
M₁ : Type ?u.2753
R : Type u_1
G : Type ?u.2759
G₀ : Type ?u.2762
inst✝⁷ : Mul M
inst✝⁶ : Monoid N
inst✝⁵ : Semigroup S
inst✝⁴ : MulZeroClass M₀
inst✝³ : MulOneClass M₁
inst✝² : NonAssocRing R
inst✝¹ : Group G
inst✝ : CancelMonoidWithZero G₀
p : R
h : IsIdempotentElem p
⊢ IsIdempotentElem (1 - p)
Theorem: unitInterval.qRight_zero_right
File: Mathlib/Topology/Homotopy/HSpaces.lean

tactic: simp only [qRight, coe_zero, add_zero, div_one]
state_before: t : ↑I
⊢ ↑(qRight (t, 0)) = if ↑t ≤ 1 / 2 then 2 * ↑t else 1

tactic: split_ifs
state_before: t : ↑I
⊢ ↑(Set.projIcc 0 1 qRight.proof_1 (2 * ↑t)) = if ↑t ≤ 1 / 2 then 2 * ↑t else 1

tactic: rw [Set.projIcc_of_mem _ ((mul_pos_mem_iff zero_lt_two).2 _)]
state_before: case inl
t : ↑I
h✝ : ↑t ≤ 1 / 2
⊢ ↑(Set.projIcc 0 1 qRight.proof_1 (2 * ↑t)) = 2 * ↑t

tactic: refine' ⟨t.2.1, _⟩
state_before: t : ↑I
h✝ : ↑t ≤ 1 / 2
⊢ ↑t ∈ Set.Icc 0 (1 / 2)

tactic: tauto
state_before: t : ↑I
h✝ : ↑t ≤ 1 / 2
⊢ ↑t ≤ 1 / 2

tactic: rw [(Set.projIcc_eq_right _).2]
state_before: case inr
t : ↑I
h✝ : ¬↑t ≤ 1 / 2
⊢ ↑(Set.projIcc 0 1 qRight.proof_1 (2 * ↑t)) = 1

tactic: linarith
state_before: case inr
t : ↑I
h✝ : ¬↑t ≤ 1 / 2
⊢ 1 ≤ 2 * ↑t

tactic: exact zero_lt_one
state_before: t : ↑I
h✝ : ¬↑t ≤ 1 / 2
⊢ 0 < 1
Theorem: Int.addLeft_one_isCycle
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp
state_before: ι : Type ?u.3065754
α : Type ?u.3065757
β : Type ?u.3065760
inst✝ : DecidableEq α
n : ℤ
x✝ : ↑(Equiv.addLeft 1) n ≠ n
⊢ ↑(Equiv.addLeft 1 ^ n) 0 = n
Theorem: MeasureTheory.lintegral_finset_sum'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: induction' s using Finset.induction_on with a s has ih
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.929424
δ : Type ?u.929427
m : MeasurableSpace α
μ ν : Measure α
s : Finset β
f : β → α → ℝ≥0∞
hf : ∀ (b : β), b ∈ s → AEMeasurable (f b)
⊢ (∫⁻ (a : α), ∑ b in s, f b a ∂μ) = ∑ b in s, ∫⁻ (a : α), f b a ∂μ

tactic: simp
state_before: case empty
α : Type u_2
β : Type u_1
γ : Type ?u.929424
δ : Type ?u.929427
m : MeasurableSpace α
μ ν : Measure α
s : Finset β
f : β → α → ℝ≥0∞
hf✝ : ∀ (b : β), b ∈ s → AEMeasurable (f b)
hf : ∀ (b : β), b ∈ ∅ → AEMeasurable (f b)
⊢ (∫⁻ (a : α), ∑ b in ∅, f b a ∂μ) = ∑ b in ∅, ∫⁻ (a : α), f b a ∂μ

tactic: simp only [Finset.sum_insert has]
state_before: case insert
α : Type u_2
β : Type u_1
γ : Type ?u.929424
δ : Type ?u.929427
m : MeasurableSpace α
μ ν : Measure α
s✝ : Finset β
f : β → α → ℝ≥0∞
hf✝ : ∀ (b : β), b ∈ s✝ → AEMeasurable (f b)
a : β
s : Finset β
has : ¬a ∈ s
ih : (∀ (b : β), b ∈ s → AEMeasurable (f b)) → (∫⁻ (a : α), ∑ b in s, f b a ∂μ) = ∑ b in s, ∫⁻ (a : α), f b a ∂μ
hf : ∀ (b : β), b ∈ insert a s → AEMeasurable (f b)
⊢ (∫⁻ (a_1 : α), ∑ b in insert a s, f b a_1 ∂μ) = ∑ b in insert a s, ∫⁻ (a : α), f b a ∂μ

tactic: rw [Finset.forall_mem_insert] at hf
state_before: case insert
α : Type u_2
β : Type u_1
γ : Type ?u.929424
δ : Type ?u.929427
m : MeasurableSpace α
μ ν : Measure α
s✝ : Finset β
f : β → α → ℝ≥0∞
hf✝ : ∀ (b : β), b ∈ s✝ → AEMeasurable (f b)
a : β
s : Finset β
has : ¬a ∈ s
ih : (∀ (b : β), b ∈ s → AEMeasurable (f b)) → (∫⁻ (a : α), ∑ b in s, f b a ∂μ) = ∑ b in s, ∫⁻ (a : α), f b a ∂μ
hf : ∀ (b : β), b ∈ insert a s → AEMeasurable (f b)
⊢ (∫⁻ (a_1 : α), f a a_1 + ∑ b in s, f b a_1 ∂μ) = (∫⁻ (a_1 : α), f a a_1 ∂μ) + ∑ b in s, ∫⁻ (a : α), f b a ∂μ

tactic: rw [lintegral_add_left' hf.1, ih hf.2]
state_before: case insert
α : Type u_2
β : Type u_1
γ : Type ?u.929424
δ : Type ?u.929427
m : MeasurableSpace α
μ ν : Measure α
s✝ : Finset β
f : β → α → ℝ≥0∞
hf✝ : ∀ (b : β), b ∈ s✝ → AEMeasurable (f b)
a : β
s : Finset β
has : ¬a ∈ s
ih : (∀ (b : β), b ∈ s → AEMeasurable (f b)) → (∫⁻ (a : α), ∑ b in s, f b a ∂μ) = ∑ b in s, ∫⁻ (a : α), f b a ∂μ
hf : AEMeasurable (f a) ∧ ∀ (x : β), x ∈ s → AEMeasurable (f x)
⊢ (∫⁻ (a_1 : α), f a a_1 + ∑ b in s, f b a_1 ∂μ) = (∫⁻ (a_1 : α), f a a_1 ∂μ) + ∑ b in s, ∫⁻ (a : α), f b a ∂μ
Theorem: ENNReal.inv_two_add_inv_two
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [← two_mul, ← div_eq_mul_inv, ENNReal.div_self two_ne_zero two_ne_top]
state_before: α : Type ?u.312605
β : Type ?u.312608
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ 2⁻¹ + 2⁻¹ = 1
Theorem: Cubic.d_eq_three_roots
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: injection eq_sum_three_roots ha h3
state_before: R : Type ?u.1111262
S : Type ?u.1111265
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ ↑φ P.d = ↑φ P.a * -(x * y * z)
Theorem: rank_directSum
File: Mathlib/LinearAlgebra/FreeModule/Rank.lean

tactic: let B i := chooseBasis R (M i)
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✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : Module.Free R N
ι : Type v
M : ι → Type w
inst✝² : (i : ι) → AddCommGroup (M i)
inst✝¹ : (i : ι) → Module R (M i)
inst✝ : ∀ (i : ι), Module.Free R (M i)
⊢ Module.rank R (⨁ (i : ι), M i) = sum fun i => Module.rank R (M i)

tactic: let b : Basis _ R (⨁ i, M i) := Dfinsupp.basis fun i => B i
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✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : Module.Free R N
ι : Type v
M : ι → Type w
inst✝² : (i : ι) → AddCommGroup (M i)
inst✝¹ : (i : ι) → Module R (M i)
inst✝ : ∀ (i : ι), Module.Free R (M i)
B : (i : ι) → Basis (ChooseBasisIndex R (M i)) R (M i) := fun i => chooseBasis R (M i)
⊢ Module.rank R (⨁ (i : ι), M i) = sum fun i => Module.rank R (M i)

tactic: simp [← b.mk_eq_rank'', fun i => (B i).mk_eq_rank'']
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✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : Module.Free R N
ι : Type v
M : ι → Type w
inst✝² : (i : ι) → AddCommGroup (M i)
inst✝¹ : (i : ι) → Module R (M i)
inst✝ : ∀ (i : ι), Module.Free R (M i)
B : (i : ι) → Basis (ChooseBasisIndex R (M i)) R (M i) := fun i => chooseBasis R (M i)
b : Basis ((i : ι) × ChooseBasisIndex R (M i)) R (⨁ (i : ι), M i) := Dfinsupp.basis fun i => B i
⊢ Module.rank R (⨁ (i : ι), M i) = sum fun i => Module.rank R (M i)
Theorem: PNat.XgcdType.finish_isReduced
File: Mathlib/Data/PNat/Xgcd.lean

tactic: dsimp [IsReduced]
state_before: u : XgcdType
⊢ IsReduced (finish u)

tactic: rfl
state_before: u : XgcdType
⊢ (finish u).ap = (finish u).bp
Theorem: OrderMonoidWithZeroHom.toMonoidWithZeroHom_injective
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: convert FunLike.ext_iff.1 h using 0
state_before: F : Type ?u.124488
α : Type u_1
β : Type u_2
γ : Type ?u.124497
δ : Type ?u.124500
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulZeroOneClass α
inst✝² : MulZeroOneClass β
inst✝¹ : MulZeroOneClass γ
inst✝ : MulZeroOneClass δ
f✝ g✝ f g : α →*₀o β
h : f.toMonoidWithZeroHom = g.toMonoidWithZeroHom
⊢ ∀ (a : α), ↑f a = ↑g a
Theorem: EckmannHilton.mul_assoc
File: Mathlib/GroupTheory/EckmannHilton.lean

tactic: simpa [mul h₁ h₂ distrib, h₂.left_id, h₂.right_id] using distrib a b e₂ c
state_before: X : Type u
m₁ m₂ : X → X → X
e₁ e₂ : X
h₁ : IsUnital m₁ e₁
h₂ : IsUnital m₂ e₂
distrib : ∀ (a b c d : X), m₁ (m₂ a b) (m₂ c d) = m₂ (m₁ a c) (m₁ b d)
a b c : X
⊢ m₂ (m₂ a b) c = m₂ a (m₂ b c)
Theorem: Filter.map_const_principal_coprod_map_id_principal
File: Mathlib/Order/Filter/Prod.lean

tactic: simp only [map_principal, Filter.coprod, comap_principal, sup_principal, image_singleton,
  image_id, prod_univ, univ_prod, id]
state_before: α✝ : Type ?u.65740
β✝ : Type ?u.65743
γ : Type ?u.65746
δ : Type ?u.65749
ι✝ : Sort ?u.65752
f : Filter α✝
g : Filter β✝
α : Type u_1
β : Type u_2
ι : Type u_3
a : α
b : β
i : ι
⊢ Filter.coprod (map (fun x => b) (𝓟 {a})) (map id (𝓟 {i})) = 𝓟 ({b} ×ˢ univ ∪ univ ×ˢ {i})
Theorem: Finset.mulEtransformRight.fst_mul_snd_subset
File: Mathlib/Combinatorics/Additive/Etransform.lean

tactic: refine' union_mul_inter_subset_union.trans (union_subset Subset.rfl _)
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Group α
e : α
x : Finset α × Finset α
⊢ (mulEtransformRight e x).fst * (mulEtransformRight e x).snd ⊆ x.fst * x.snd

tactic: rw [op_smul_finset_mul_eq_mul_smul_finset, smul_inv_smul]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Group α
e : α
x : Finset α × Finset α
⊢ op e • x.fst * e⁻¹ • x.snd ⊆ x.fst * x.snd
Theorem: interior_sphere'
File: Mathlib/Analysis/NormedSpace/Basic.lean

tactic: rw [← frontier_closedBall' x, interior_frontier isClosed_ball]
state_before: α : Type ?u.309886
β : Type ?u.309889
γ : Type ?u.309892
ι : Type ?u.309895
inst✝⁶ : NormedField α
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace α E
F : Type ?u.309988
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace α F
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
r : ℝ
⊢ interior (sphere x r) = ∅
Theorem: Nat.minFac_eq_one_iff
File: Mathlib/Data/Nat/Prime.lean

tactic: constructor
state_before: n : ℕ
⊢ minFac n = 1 ↔ n = 1

tactic: intro h
state_before: case mp
n : ℕ
⊢ minFac n = 1 → n = 1

tactic: by_contra hn
state_before: case mp
n : ℕ
h : minFac n = 1
⊢ n = 1

tactic: have := minFac_prime hn
state_before: case mp
n : ℕ
h : minFac n = 1
hn : ¬n = 1
⊢ False

tactic: rw [h] at this
state_before: case mp
n : ℕ
h : minFac n = 1
hn : ¬n = 1
this : Prime (minFac n)
⊢ False

tactic: exact not_prime_one this
state_before: case mp
n : ℕ
h : minFac n = 1
hn : ¬n = 1
this : Prime 1
⊢ False

tactic: rintro rfl
state_before: case mpr
n : ℕ
⊢ n = 1 → minFac n = 1

tactic: rfl
state_before: case mpr

⊢ minFac 1 = 1
Theorem: Nat.dist_tri_left'
File: Mathlib/Data/Nat/Dist.lean

tactic: rw [dist_comm]
state_before: n m : ℕ
⊢ n ≤ dist n m + m

tactic: apply dist_tri_left
state_before: n m : ℕ
⊢ n ≤ dist m n + m