tasksource/leandojo huggingface dataset:
Theorem: Equiv.Perm.support_cycleOf_le
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: intro y hy
state_before: ι : Type ?u.2513584
α : Type u_1
β : Type ?u.2513590
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
x : α
⊢ support (cycleOf f x) ≤ support f

tactic: rw [mem_support, cycleOf_apply] at hy
state_before: ι : Type ?u.2513584
α : Type u_1
β : Type ?u.2513590
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y✝ : α
f : Perm α
x y : α
hy : y ∈ support (cycleOf f x)
⊢ y ∈ support f

tactic: split_ifs  at hy
state_before: ι : Type ?u.2513584
α : Type u_1
β : Type ?u.2513590
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y✝ : α
f : Perm α
x y : α
hy : (if SameCycle f x y then ↑f y else y) ≠ y
⊢ y ∈ support f

tactic: exact mem_support.mpr hy
state_before: case inl
ι : Type ?u.2513584
α : Type u_1
β : Type ?u.2513590
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y✝ : α
f : Perm α
x y : α
h✝ : SameCycle f x y
hy : ↑f y ≠ y
⊢ y ∈ support f

tactic: exact absurd rfl hy
state_before: case inr
ι : Type ?u.2513584
α : Type u_1
β : Type ?u.2513590
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y✝ : α
f : Perm α
x y : α
h✝ : ¬SameCycle f x y
hy : y ≠ y
⊢ y ∈ support f
Theorem: MeasureTheory.ae_eq_restrict_biUnion_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp_rw [ae_restrict_biUnion_eq s ht, EventuallyEq, eventually_iSup]
state_before: α : Type u_1
β : Type ?u.563935
γ : Type ?u.563938
δ : Type u_3
ι : Type u_2
R : Type ?u.563947
R' : Type ?u.563950
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
s : ι → Set α
t : Set ι
ht : Set.Countable t
f g : α → δ
⊢ f =ᶠ[ae (Measure.restrict μ (⋃ (i : ι) (_ : i ∈ t), s i))] g ↔
    ∀ (i : ι), i ∈ t → f =ᶠ[ae (Measure.restrict μ (s i))] g
Theorem: Function.mulSupport_prod_mk
File: Mathlib/Algebra/Support.lean

tactic: simp only [mulSupport, not_and_or, mem_union, mem_setOf_eq, Prod.mk_eq_one, Ne.def]
state_before: α : Type u_1
β : Type ?u.15742
A : Type ?u.15745
B : Type ?u.15748
M : Type u_3
N : Type u_2
P : Type ?u.15757
R : Type ?u.15760
S : Type ?u.15763
G : Type ?u.15766
M₀ : Type ?u.15769
G₀ : Type ?u.15772
ι : Sort ?u.15775
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M
g : α → N
x : α
⊢ (x ∈ mulSupport fun x => (f x, g x)) ↔ x ∈ mulSupport f ∪ mulSupport g
Theorem: List.formPerm_cons_concat_apply_last
File: Mathlib/GroupTheory/Perm/List.lean

tactic: induction' xs with z xs IH generalizing x y
state_before: α : Type u_1
β : Type ?u.665997
inst✝ : DecidableEq α
l : List α
x✝ x y : α
xs : List α
⊢ ↑(formPerm (x :: (xs ++ [y]))) y = x

tactic: simp
state_before: case nil
α : Type u_1
β : Type ?u.665997
inst✝ : DecidableEq α
l : List α
x✝¹ x✝ y✝ x y : α
⊢ ↑(formPerm (x :: ([] ++ [y]))) y = x

tactic: simp [IH]
state_before: case cons
α : Type u_1
β : Type ?u.665997
inst✝ : DecidableEq α
l : List α
x✝¹ x✝ y✝ z : α
xs : List α
IH : ∀ (x y : α), ↑(formPerm (x :: (xs ++ [y]))) y = x
x y : α
⊢ ↑(formPerm (x :: (z :: xs ++ [y]))) y = x
Theorem: sign_mul_abs
File: Mathlib/Data/Sign.lean

tactic: rcases lt_trichotomy x 0 with (hx | rfl | hx)
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
a b x : α
⊢ ↑(↑sign x) * abs x = x

tactic: rw [sign_neg hx, abs_of_neg hx, coe_neg_one, neg_one_mul, neg_neg]
state_before: case inl
α : Type u_1
inst✝ : LinearOrderedRing α
a b x : α
hx : x < 0
⊢ ↑(↑sign x) * abs x = x

tactic: rw [abs_zero, mul_zero]
state_before: case inr.inl
α : Type u_1
inst✝ : LinearOrderedRing α
a b : α
⊢ ↑(↑sign 0) * abs 0 = 0

tactic: rw [sign_pos hx, abs_of_pos hx, coe_one, one_mul]
state_before: case inr.inr
α : Type u_1
inst✝ : LinearOrderedRing α
a b x : α
hx : 0 < x
⊢ ↑(↑sign x) * abs x = x
Theorem: infinite_of_mem_nhds
File: Mathlib/Topology/Separation.lean

tactic: refine' fun hsf => hx.1 _
state_before: α✝ : Type u
β : Type v
inst✝² : TopologicalSpace α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
x : α
hx : NeBot (𝓝[{x}ᶜ] x)
s : Set α
hs : s ∈ 𝓝 x
⊢ Set.Infinite s

tactic: rw [← isOpen_singleton_iff_punctured_nhds]
state_before: α✝ : Type u
β : Type v
inst✝² : TopologicalSpace α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
x : α
hx : NeBot (𝓝[{x}ᶜ] x)
s : Set α
hs : s ∈ 𝓝 x
hsf : Set.Finite s
⊢ 𝓝[{x}ᶜ] x = ⊥

tactic: exact isOpen_singleton_of_finite_mem_nhds x hs hsf
state_before: α✝ : Type u
β : Type v
inst✝² : TopologicalSpace α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
x : α
hx : NeBot (𝓝[{x}ᶜ] x)
s : Set α
hs : s ∈ 𝓝 x
hsf : Set.Finite s
⊢ IsOpen {x}
Theorem: LieAlgebra.ExtendScalars.bracket'_tmul
File: Mathlib/Algebra/Lie/BaseChange.lean

tactic: simp [bracket']
state_before: R : Type u
A : Type w
L : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
s t : A
x y : L
⊢ ↑(↑(LieAlgebra.ExtendScalars.bracket' R A L) (s ⊗ₜ[R] x)) (t ⊗ₜ[R] y) = (s * t) ⊗ₜ[R] ⁅x, y⁆
Theorem: CategoryTheory.eq_of_comp_left_eq'
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: convert congr_fun (congr_fun w Z) h
state_before: C : Type u
inst✝ : Category C
X Y Z✝ : C
f g : X ⟶ Y
w : (fun {Z} h => f ≫ h) = fun {Z} h => g ≫ h
Z : C
h : Y ⟶ Z
⊢ f ≫ h = g ≫ h
Theorem: Bool.eq_iff_iff
File: Std/Logic.lean

tactic: cases b <;> simp
state_before: a b : Bool
⊢ a = b ↔ (a = true ↔ b = true)
Theorem: ContinuousLinearMap.prod_ext_iff
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: simp only [← coe_inj, LinearMap.prod_ext_iff]
state_before: R : Type u_1
R₂ : Type ?u.1139458
R₃ : Type ?u.1139461
S : Type ?u.1139464
S₃ : Type ?u.1139467
inst✝²⁹ : Semiring R
inst✝²⁸ : Semiring R₂
inst✝²⁷ : Semiring R₃
inst✝²⁶ : Semiring S
inst✝²⁵ : Semiring S₃
M : Type u_3
inst✝²⁴ : TopologicalSpace M
inst✝²³ : AddCommMonoid M
inst✝²² : Module R M
M₂ : Type ?u.1139520
inst✝²¹ : TopologicalSpace M₂
inst✝²⁰ : AddCommMonoid M₂
inst✝¹⁹ : Module R₂ M₂
M₃ : Type ?u.1139555
inst✝¹⁸ : TopologicalSpace M₃
inst✝¹⁷ : AddCommMonoid M₃
inst✝¹⁶ : Module R₃ M₃
N₂ : Type u_2
inst✝¹⁵ : TopologicalSpace N₂
inst✝¹⁴ : AddCommMonoid N₂
inst✝¹³ : Module R N₂
N₃ : Type u_4
inst✝¹² : TopologicalSpace N₃
inst✝¹¹ : AddCommMonoid N₃
inst✝¹⁰ : Module R N₃
inst✝⁹ : Module S₃ M₃
inst✝⁸ : SMulCommClass R₃ S₃ M₃
inst✝⁷ : ContinuousConstSMul S₃ M₃
inst✝⁶ : Module S N₂
inst✝⁵ : ContinuousConstSMul S N₂
inst✝⁴ : SMulCommClass R S N₂
inst✝³ : Module S N₃
inst✝² : SMulCommClass R S N₃
inst✝¹ : ContinuousConstSMul S N₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
c : S
h : M₂ →SL[σ₂₃] M₃
f✝ g✝ : M →SL[σ₁₂] M₂
x y z : M
f g : M × N₂ →L[R] N₃
⊢ f = g ↔ comp f (inl R M N₂) = comp g (inl R M N₂) ∧ comp f (inr R M N₂) = comp g (inr R M N₂)

tactic: rfl
state_before: R : Type u_1
R₂ : Type ?u.1139458
R₃ : Type ?u.1139461
S : Type ?u.1139464
S₃ : Type ?u.1139467
inst✝²⁹ : Semiring R
inst✝²⁸ : Semiring R₂
inst✝²⁷ : Semiring R₃
inst✝²⁶ : Semiring S
inst✝²⁵ : Semiring S₃
M : Type u_3
inst✝²⁴ : TopologicalSpace M
inst✝²³ : AddCommMonoid M
inst✝²² : Module R M
M₂ : Type ?u.1139520
inst✝²¹ : TopologicalSpace M₂
inst✝²⁰ : AddCommMonoid M₂
inst✝¹⁹ : Module R₂ M₂
M₃ : Type ?u.1139555
inst✝¹⁸ : TopologicalSpace M₃
inst✝¹⁷ : AddCommMonoid M₃
inst✝¹⁶ : Module R₃ M₃
N₂ : Type u_2
inst✝¹⁵ : TopologicalSpace N₂
inst✝¹⁴ : AddCommMonoid N₂
inst✝¹³ : Module R N₂
N₃ : Type u_4
inst✝¹² : TopologicalSpace N₃
inst✝¹¹ : AddCommMonoid N₃
inst✝¹⁰ : Module R N₃
inst✝⁹ : Module S₃ M₃
inst✝⁸ : SMulCommClass R₃ S₃ M₃
inst✝⁷ : ContinuousConstSMul S₃ M₃
inst✝⁶ : Module S N₂
inst✝⁵ : ContinuousConstSMul S N₂
inst✝⁴ : SMulCommClass R S N₂
inst✝³ : Module S N₃
inst✝² : SMulCommClass R S N₃
inst✝¹ : ContinuousConstSMul S N₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
c : S
h : M₂ →SL[σ₂₃] M₃
f✝ g✝ : M →SL[σ₁₂] M₂
x y z : M
f g : M × N₂ →L[R] N₃
⊢ LinearMap.comp (↑f) (LinearMap.inl R M N₂) = LinearMap.comp (↑g) (LinearMap.inl R M N₂) ∧
      LinearMap.comp (↑f) (LinearMap.inr R M N₂) = LinearMap.comp (↑g) (LinearMap.inr R M N₂) ↔
    ↑(comp f (inl R M N₂)) = ↑(comp g (inl R M N₂)) ∧ ↑(comp f (inr R M N₂)) = ↑(comp g (inr R M N₂))
Theorem: Matrix.adjugate_submatrix_equiv_self
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: ext (i j)
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
e : n ≃ m
A : Matrix m m α
⊢ adjugate (submatrix A ↑e ↑e) = submatrix (adjugate A) ↑e ↑e

tactic: rw [adjugate_apply, submatrix_apply, adjugate_apply, ← det_submatrix_equiv_self e,
  updateRow_submatrix_equiv]
state_before: case a.h
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
e : n ≃ m
A : Matrix m m α
i j : n
⊢ adjugate (submatrix A ↑e ↑e) i j = submatrix (adjugate A) (↑e) (↑e) i j

tactic: suffices (fun j => Pi.single i 1 (e.symm j)) = Pi.single (e i) 1 by
  erw [this]
state_before: case a.h
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
e : n ≃ m
A : Matrix m m α
i j : n
⊢ det (submatrix (updateRow A (↑e j) fun j => Pi.single i 1 (↑e.symm j)) ↑e ↑e) =
    det (submatrix (updateRow A (↑e j) (Pi.single (↑e i) 1)) ↑e ↑e)

tactic: exact Function.update_comp_equiv _ e.symm _ _
state_before: case a.h
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
e : n ≃ m
A : Matrix m m α
i j : n
⊢ (fun j => Pi.single i 1 (↑e.symm j)) = Pi.single (↑e i) 1

tactic: erw [this]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
e : n ≃ m
A : Matrix m m α
i j : n
this : (fun j => Pi.single i 1 (↑e.symm j)) = Pi.single (↑e i) 1
⊢ det (submatrix (updateRow A (↑e j) fun j => Pi.single i 1 (↑e.symm j)) ↑e ↑e) =
    det (submatrix (updateRow A (↑e j) (Pi.single (↑e i) 1)) ↑e ↑e)
Theorem: MvPolynomial.degreeOf_coeff_finSuccEquiv
File: Mathlib/Data/MvPolynomial/Equiv.lean

tactic: rw [degreeOf_eq_sup, degreeOf_eq_sup, Finset.sup_le_iff]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1382844
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
p : MvPolynomial (Fin (n + 1)) R
j : Fin n
i : ℕ
⊢ degreeOf j (Polynomial.coeff (↑(finSuccEquiv R n) p) i) ≤ degreeOf (Fin.succ j) p

tactic: intro m hm
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1382844
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
p : MvPolynomial (Fin (n + 1)) R
j : Fin n
i : ℕ
⊢ ∀ (b : Fin n →₀ ℕ),
    b ∈ support (Polynomial.coeff (↑(finSuccEquiv R n) p) i) → ↑b j ≤ Finset.sup (support p) fun m => ↑m (Fin.succ j)

tactic: rw [← Finsupp.cons_succ j i m]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1382844
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
p : MvPolynomial (Fin (n + 1)) R
j : Fin n
i : ℕ
m : Fin n →₀ ℕ
hm : m ∈ support (Polynomial.coeff (↑(finSuccEquiv R n) p) i)
⊢ ↑m j ≤ Finset.sup (support p) fun m => ↑m (Fin.succ j)

tactic: exact Finset.le_sup
  (f := fun (g : Fin (Nat.succ n) →₀ ℕ) => g (Fin.succ j))
  (support_coeff_finSuccEquiv.1 hm)
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1382844
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
p : MvPolynomial (Fin (n + 1)) R
j : Fin n
i : ℕ
m : Fin n →₀ ℕ
hm : m ∈ support (Polynomial.coeff (↑(finSuccEquiv R n) p) i)
⊢ ↑(cons i m) (Fin.succ j) ≤ Finset.sup (support p) fun m => ↑m (Fin.succ j)
Theorem: Set.star_inv'
File: Mathlib/Algebra/Star/Pointwise.lean

tactic: ext
state_before: α : Type u_1
s✝ t : Set α
a : α
inst✝¹ : DivisionSemiring α
inst✝ : StarRing α
s : Set α
⊢ s⁻¹⋆ = s⋆⁻¹

tactic: simp only [mem_star, mem_inv, star_inv']
state_before: case h
α : Type u_1
s✝ t : Set α
a : α
inst✝¹ : DivisionSemiring α
inst✝ : StarRing α
s : Set α
x✝ : α
⊢ x✝ ∈ s⁻¹⋆ ↔ x✝ ∈ s⋆⁻¹
Theorem: Polynomial.natDegree_mul'
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [h₁, zero_mul]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.659713
h : leadingCoeff p * leadingCoeff q ≠ 0
h₁ : leadingCoeff p = 0
⊢ leadingCoeff p * leadingCoeff q = 0

tactic: rw [h₁, mul_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.659713
h : leadingCoeff p * leadingCoeff q ≠ 0
hp : p ≠ 0
h₁ : leadingCoeff q = 0
⊢ leadingCoeff p * leadingCoeff q = 0

tactic: rw [degree_mul' h, Nat.cast_withBot, WithBot.coe_add, degree_eq_natDegree hp,
  degree_eq_natDegree hq, ← Nat.cast_withBot, ← Nat.cast_withBot]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.659713
h : leadingCoeff p * leadingCoeff q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ degree (p * q) = ↑(natDegree p + natDegree q)
Theorem: Ordinal.mul_le_of_limit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: induction a using inductionOn with
| H α r =>
  induction b using inductionOn with
  | H β s =>
    exact mul_le_of_limit_aux h H
state_before: α : Type ?u.208151
β : Type ?u.208154
γ : Type ?u.208157
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal
h : IsLimit b
H : ∀ (b' : Ordinal), b' < b → a * b' ≤ c
⊢ ¬c < a * b

tactic: induction b using inductionOn with
| H β s =>
  exact mul_le_of_limit_aux h H
state_before: case H
α✝ : Type ?u.208151
β : Type ?u.208154
γ : Type ?u.208157
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
b c : Ordinal
h : IsLimit b
α : Type u_1
r : α → α → Prop
inst✝ : IsWellOrder α r
H : ∀ (b' : Ordinal), b' < b → type r * b' ≤ c
⊢ ¬c < type r * b

tactic: exact mul_le_of_limit_aux h H
state_before: case H.H
α✝ : Type ?u.208151
β✝ : Type ?u.208154
γ : Type ?u.208157
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
c : Ordinal
α : Type u_1
r : α → α → Prop
inst✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
inst✝ : IsWellOrder β s
h : IsLimit (type s)
H : ∀ (b' : Ordinal), b' < type s → type r * b' ≤ c
⊢ ¬c < type r * type s
Theorem: Mathlib.Meta.NormNum.IsInt.neg_to_eq
File: Mathlib/Tactic/NormNum/Core.lean

tactic: simp [Int.negOfNat_eq, Int.cast_neg]
state_before: α : Type u_1
inst✝ : Ring α
n : ℕ
⊢ ↑(Int.negOfNat n) = -↑n
Theorem: FractionalIdeal.mul_right_mono
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: intro J J' h
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : FractionalIdeal S P
⊢ Monotone fun J => J * I

tactic: simp only [mul_def]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J J' : FractionalIdeal S P
h : J ≤ J'
⊢ (fun J => J * I) J ≤ (fun J => J * I) J'

tactic: exact mul_le.mpr fun x hx y hy => mul_mem_mul (h hx) hy
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J J' : FractionalIdeal S P
h : J ≤ J'
⊢ { val := ↑J * ↑I, property := (_ : IsFractional S (↑J * ↑I)) } ≤
    { val := ↑J' * ↑I, property := (_ : IsFractional S (↑J' * ↑I)) }
Theorem: CategoryTheory.Adjunction.leftAdjointUniq_hom_counit
File: Mathlib/CategoryTheory/Adjunction/Opposites.lean

tactic: ext x
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
⊢ whiskerLeft G (leftAdjointUniq adj1 adj2).hom ≫ adj2.counit = adj1.counit

tactic: apply Quiver.Hom.op_inj
state_before: case w.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : D
⊢ (whiskerLeft G (leftAdjointUniq adj1 adj2).hom ≫ adj2.counit).app x = adj1.counit.app x

tactic: apply coyoneda.map_injective
state_before: case w.h.a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : D
⊢ ((whiskerLeft G (leftAdjointUniq adj1 adj2).hom ≫ adj2.counit).app x).op = (adj1.counit.app x).op

tactic: ext
state_before: case w.h.a.a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : D
⊢ coyoneda.map ((whiskerLeft G (leftAdjointUniq adj1 adj2).hom ≫ adj2.counit).app x).op =
    coyoneda.map (adj1.counit.app x).op

tactic: funext
state_before: case w.h.a.a.w.h.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x x✝ : D
a✝ : (coyoneda.obj ((𝟭 D).obj x).op).obj x✝
⊢ (coyoneda.map ((whiskerLeft G (leftAdjointUniq adj1 adj2).hom ≫ adj2.counit).app x).op).app x✝ a✝ =
    (coyoneda.map (adj1.counit.app x).op).app x✝ a✝

tactic: simp [leftAdjointUniq, leftAdjointsCoyonedaEquiv]
state_before: case w.h.a.a.w.h.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x x✝ : D
a✝ : (coyoneda.obj ((𝟭 D).obj x).op).obj x✝
⊢ (coyoneda.map ((whiskerLeft G (leftAdjointUniq adj1 adj2).hom ≫ adj2.counit).app x).op).app x✝ a✝ =
    (coyoneda.map (adj1.counit.app x).op).app x✝ a✝
Theorem: Int.mul_ediv_mul_of_pos_left
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm, Int.mul_comm c, mul_ediv_mul_of_pos _ _ H]
state_before: a b c : Int
H : 0 < b
⊢ a * b / (c * b) = a / c
Theorem: Int.toNat_of_nonpos
File: Mathlib/Data/Int/Lemmas.lean

tactic: simp
state_before: a b : ℤ
n✝ n : ℕ
h : ↑(n + 1) ≤ 0
⊢ 0 < ↑(n + 1)
Theorem: FractionalIdeal.mul_inv_cancel_iff
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rwa [← right_inverse_eq K I J hJ]
state_before: R : Type ?u.28285
A : Type ?u.28288
K : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : Field K
inst✝⁴ : IsDomain A
R₁ : Type u_1
inst✝³ : CommRing R₁
inst✝² : IsDomain R₁
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
I✝ J✝ I : FractionalIdeal R₁⁰ K
x✝ : ∃ J, I * J = 1
J : FractionalIdeal R₁⁰ K
hJ : I * J = 1
⊢ I * I⁻¹ = 1
Theorem: ite_ne_left_iff
File: Mathlib/Logic/Basic.lean

tactic: simp only
state_before: α : Sort u_1
β : Sort ?u.36335
σ : α → Sort ?u.36331
f : α → β
P Q : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b c : α
A : P → α
B : ¬P → α
⊢ (∃ h, a ≠ (fun x => b) h) ↔ ¬P ∧ a ≠ b

tactic: rw [exists_prop]
state_before: α : Sort u_1
β : Sort ?u.36335
σ : α → Sort ?u.36331
f : α → β
P Q : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b c : α
A : P → α
B : ¬P → α
⊢ (∃ h, a ≠ b) ↔ ¬P ∧ a ≠ b
Theorem: rotation_trans
File: Mathlib/Analysis/Complex/Isometry.lean

tactic: ext1
state_before: a b : { x // x ∈ circle }
⊢ LinearIsometryEquiv.trans (↑rotation a) (↑rotation b) = ↑rotation (b * a)

tactic: simp
state_before: case h
a b : { x // x ∈ circle }
x✝ : ℂ
⊢ ↑(LinearIsometryEquiv.trans (↑rotation a) (↑rotation b)) x✝ = ↑(↑rotation (b * a)) x✝
Theorem: inf_eq_minDefault
File: Mathlib/Order/Lattice.lean

tactic: ext (x y)
state_before: α : Type u
β : Type v
inst✝² : SemilatticeInf α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
⊢ (fun x x_1 => x ⊓ x_1) = minDefault

tactic: unfold minDefault
state_before: case h.h
α : Type u
β : Type v
inst✝² : SemilatticeInf α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
⊢ x ⊓ y = minDefault x y

tactic: split_ifs with h'
state_before: case h.h
α : Type u
β : Type v
inst✝² : SemilatticeInf α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
⊢ x ⊓ y = if x ≤ y then x else y
Theorem: Subgroup.exists_smul_eq
File: Mathlib/GroupTheory/SchurZassenhaus.lean

tactic: rw [inv_pow, ← powCoprime_apply hH, Equiv.apply_symm_apply, mul_inv_self]
state_before: G : Type u_1
inst✝³ : Group G
H : Subgroup G
inst✝² : IsCommutative H
inst✝¹ : FiniteIndex H
α✝¹ β✝¹ : ↑(leftTransversals ↑H)
inst✝ : Normal H
hH : Nat.coprime (Nat.card { x // x ∈ H }) (index H)
α✝ β✝ : QuotientDiff H
β α : ↑(leftTransversals ↑H)
⊢ diff (MonoidHom.id { x // x ∈ H }) β α *
      (↑(powCoprime hH).symm (diff (MonoidHom.id { x // x ∈ H }) β α))⁻¹ ^ index H =
    1
Theorem: Equiv.pointReflection_symm
File: Mathlib/Algebra/AddTorsor.lean

tactic: simp [pointReflection]
state_before: G : Type u_2
P : Type u_1
inst✝¹ : AddGroup G
inst✝ : AddTorsor G P
x : P
⊢ ∀ (x_1 : P), ↑(pointReflection x).symm x_1 = ↑(pointReflection x) x_1
Theorem: AddLECancellable.tsub_lt_self_iff
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: refine'
  ⟨fun h => ⟨(zero_le _).trans_lt h, (zero_le b).lt_of_ne _⟩, fun h => ha.tsub_lt_self h.1 h.2⟩
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
⊢ a - b < a ↔ 0 < a ∧ 0 < b

tactic: rintro rfl
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
h : a - b < a
⊢ 0 ≠ b

tactic: rw [tsub_zero] at h
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a c d : α
ha : AddLECancellable a
h : a - 0 < a
⊢ False

tactic: exact h.false
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a c d : α
ha : AddLECancellable a
h : a < a
⊢ False
Theorem: PowerSeries.coeff_succ_X_mul
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp only [coeff, Finsupp.single_add, add_comm n 1]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : PowerSeries R
⊢ ↑(coeff R (n + 1)) (X * φ) = ↑(coeff R n) φ

tactic: convert φ.coeff_add_monomial_mul (single () 1) (single () n) _
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : PowerSeries R
⊢ ↑(MvPowerSeries.coeff R (single () 1 + single () n)) (X * φ) = ↑(MvPowerSeries.coeff R (single () n)) φ

tactic: rw [one_mul]
state_before: case h.e'_3
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : PowerSeries R
⊢ ↑(MvPowerSeries.coeff R (single () n)) φ = 1 * ↑(MvPowerSeries.coeff R (single () n)) φ
Theorem: Set.right_mem_Ioc
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp [le_refl]
state_before: α : Type u_1
β : Type ?u.5581
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ b ∈ Ioc a b ↔ a < b
Theorem: MeasureTheory.lintegral_iUnion₀
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [Measure.restrict_iUnion_ae hd hm, lintegral_sum_measure]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.1020799
δ : Type ?u.1020802
m : MeasurableSpace α
μ ν : Measure α
inst✝ : Countable β
s : β → Set α
hm : ∀ (i : β), NullMeasurableSet (s i)
hd : Pairwise (AEDisjoint μ on s)
f : α → ℝ≥0∞
⊢ (∫⁻ (a : α) in ⋃ (i : β), s i, f a ∂μ) = ∑' (i : β), ∫⁻ (a : α) in s i, f a ∂μ
Theorem: Nat.coprime_zero_right
File: Std/Data/Nat/Gcd.lean

tactic: simp [coprime]
state_before: n : Nat
⊢ coprime n 0 ↔ n = 1
Theorem: OrderedCommGroup.to_contravariantClass_left_le
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: simpa using mul_le_mul_left' bc a⁻¹
state_before: α✝ α : Type u
inst✝ : OrderedCommGroup α
a b c : α
bc : a * b ≤ a * c
⊢ b ≤ c
Theorem: ENNReal.coe_smul
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [← smul_one_smul ℝ≥0 r (s : ℝ≥0∞), smul_def, smul_eq_mul, ← ENNReal.coe_mul, smul_mul_assoc,
  one_mul]
state_before: α : Type ?u.74308
β : Type ?u.74311
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
R : Type u_1
r : R
s : ℝ≥0
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ≥0∞
⊢ ↑(r • s) = r • ↑s
Theorem: Ordinal.IsFundamentalSequence.cof_eq
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [← hf.2.2]
state_before: α : Type ?u.67959
r : α → α → Prop
a o : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
⊢ ord (cof a) ≤ o

tactic: exact (ord_le_ord.2 (cof_blsub_le f)).trans (ord_card_le o)
state_before: α : Type ?u.67959
r : α → α → Prop
a o : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
⊢ ord (cof (blsub o f)) ≤ o
Theorem: Metric.bounded_union
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [bounded_iff_isBounded, isBounded_union]
state_before: α : Type u
β : Type v
X : Type ?u.491428
ι : Type ?u.491431
inst✝ : PseudoMetricSpace α
x : α
s t : Set α
r : ℝ
⊢ Bounded (s ∪ t) ↔ Bounded s ∧ Bounded t