tasksource/leandojo huggingface dataset:
Theorem: Pell.y_dvd_iff
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: have co : Nat.coprime (yn a1 m) (xn a1 (m * (n / m))) :=
  Nat.coprime.symm <| (xy_coprime a1 _).coprime_dvd_right (y_mul_dvd a1 m (n / m))
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ yn a1 n
hp : n % m > 0
⊢ False

tactic: have m0 : 0 < m :=
  m.eq_zero_or_pos.resolve_left fun e => by
    rw [e, Nat.mod_zero] at hp;rw [e] at h
    exact _root_.ne_of_lt (strictMono_y a1 hp) (eq_zero_of_zero_dvd h).symm
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ yn a1 n
hp : n % m > 0
co : coprime (yn a1 m) (xn a1 (m * (n / m)))
⊢ False

tactic: rw [← Nat.mod_add_div n m, yn_add] at h
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ yn a1 n
hp : n % m > 0
co : coprime (yn a1 m) (xn a1 (m * (n / m)))
m0 : 0 < m
⊢ False

tactic: exact
  not_le_of_gt (strictMono_y _ <| Nat.mod_lt n m0)
    (Nat.le_of_dvd (strictMono_y _ hp) <|
      co.dvd_of_dvd_mul_right <|
        (Nat.dvd_add_iff_right <| (y_mul_dvd _ _ _).mul_left _).2 h)
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ xn a1 (n % m) * yn a1 (m * (n / m)) + yn a1 (n % m) * xn a1 (m * (n / m))
hp : n % m > 0
co : coprime (yn a1 m) (xn a1 (m * (n / m)))
m0 : 0 < m
⊢ False

tactic: rw [e, Nat.mod_zero] at hp
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ yn a1 n
hp : n % m > 0
co : coprime (yn a1 m) (xn a1 (m * (n / m)))
e : m = 0
⊢ False

tactic: rw [e] at h
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ yn a1 n
hp : n > 0
co : coprime (yn a1 m) (xn a1 (m * (n / m)))
e : m = 0
⊢ False

tactic: exact _root_.ne_of_lt (strictMono_y a1 hp) (eq_zero_of_zero_dvd h).symm
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 0 ∣ yn a1 n
hp : n > 0
co : coprime (yn a1 m) (xn a1 (m * (n / m)))
e : m = 0
⊢ False

tactic: rw [e]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
x✝ : m ∣ n
k : ℕ
e : n = m * k
⊢ yn a1 m ∣ yn a1 n

tactic: apply y_mul_dvd
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
x✝ : m ∣ n
k : ℕ
e : n = m * k
⊢ yn a1 m ∣ yn a1 (m * k)
Theorem: ProjectiveSpectrum.basicOpen_one
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: simp
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
⊢ ↑(basicOpen 𝒜 1) = ↑⊤
Theorem: Holor.mul_scalar_mul
File: Mathlib/Data/Holor.lean

tactic: simp [mul, SMul.smul, HolorIndex.take, HolorIndex.drop, HSMul.hSMul]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Monoid α
x : Holor α []
y : Holor α ds
⊢ x ⊗ y = x { val := [], property := (_ : Forall₂ (fun x x_1 => x < x_1) [] []) } • y
Theorem: CategoryTheory.GrothendieckTopology.toSheafify_sheafifyLift
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: dsimp only [sheafifyLift, toSheafify]
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
⊢ toSheafify J P ≫ sheafifyLift J η hQ = η

tactic: simp
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
⊢ (toPlus J P ≫ plusMap J (toPlus J P)) ≫ plusLift J (plusLift J η hQ) hQ = η
Theorem: Set.mul_mem_centralizer
File: Mathlib/GroupTheory/Subsemigroup/Centralizer.lean

tactic: rw [mul_assoc, ← hb g hg, ← mul_assoc, ha g hg, mul_assoc]
state_before: M : Type u_1
S T : Set M
a b : M
inst✝ : Semigroup M
ha : a ∈ centralizer S
hb : b ∈ centralizer S
g : M
hg : g ∈ S
⊢ g * (a * b) = a * b * g
Theorem: Order.Ideal.top_of_top_mem
File: Mathlib/Order/Ideal.lean

tactic: ext
state_before: P : Type u_1
inst✝¹ : LE P
inst✝ : OrderTop P
I : Ideal P
h : ⊤ ∈ I
⊢ I = ⊤

tactic: exact iff_of_true (I.lower le_top h) trivial
state_before: case a.h
P : Type u_1
inst✝¹ : LE P
inst✝ : OrderTop P
I : Ideal P
h : ⊤ ∈ I
x✝ : P
⊢ x✝ ∈ ↑I ↔ x✝ ∈ ↑⊤
Theorem: MeasureTheory.FiniteMeasure.restrict_eq_zero_iff
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: rw [← mass_zero_iff, restrict_mass]
state_before: Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type ?u.40459
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ : FiniteMeasure Ω
A : Set Ω
⊢ restrict μ A = 0 ↔ (fun s => ENNReal.toNNReal (↑↑↑μ s)) A = 0
Theorem: Ultrafilter.coe_injective
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: congr
state_before: α : Type u
β : Type v
γ : Type ?u.3235
f✝ g✝ : Ultrafilter α
s t : Set α
p q : α → Prop
f : Filter α
h₁ : NeBot f
h₂ : ∀ (g : Filter α), NeBot g → g ≤ f → f ≤ g
g : Filter α
neBot'✝ : NeBot g
le_of_le✝ : ∀ (g_1 : Filter α), NeBot g_1 → g_1 ≤ g → g ≤ g_1
x✝ : ↑{ toFilter := f, neBot' := h₁, le_of_le := h₂ } = ↑{ toFilter := g, neBot' := neBot'✝, le_of_le := le_of_le✝ }
⊢ { toFilter := f, neBot' := h₁, le_of_le := h₂ } = { toFilter := g, neBot' := neBot'✝, le_of_le := le_of_le✝ }
Theorem: Ideal.mem_jacobson_bot
File: Mathlib/RingTheory/JacobsonIdeal.lean

tactic: rwa [add_mul, one_mul, ← sub_eq_zero, mul_right_comm, mul_comm _ z, mul_right_comm]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
x : R
hx : x ∈ jacobson ⊥
y z : R
hz : z * y * x + z - 1 ∈ ⊥
⊢ (x * y + 1) * z = 1

tactic: ring
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
x : R
h : ∀ (y : R), IsUnit (x * y + 1)
y b : R
hb : (x * y + 1) * b = 1
⊢ b * y * x + b - (x * y + 1) * b = 0
Theorem: LinearMap.coprod_inl
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.62156
M₆ : Type ?u.62159
S : Type ?u.62162
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f✝ : M →ₗ[R] M₂
f : M →ₗ[R] M₃
g : M₂ →ₗ[R] M₃
⊢ comp (coprod f g) (inl R M M₂) = f

tactic: simp only [map_zero, add_zero, coprod_apply, inl_apply, comp_apply]
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.62156
M₆ : Type ?u.62159
S : Type ?u.62162
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f✝ : M →ₗ[R] M₂
f : M →ₗ[R] M₃
g : M₂ →ₗ[R] M₃
x✝ : M
⊢ ↑(comp (coprod f g) (inl R M M₂)) x✝ = ↑f x✝
Theorem: Num.ofNat'_succ
File: Mathlib/Data/Num/Lemmas.lean

tactic: simp
state_before: α : Type ?u.180035
⊢ ofNat' (0 + 1) = ofNat' 0 + 1

tactic: cases b
state_before: α : Type ?u.180035
b : Bool
n : ℕ
ih : ofNat' (n + 1) = ofNat' n + 1
⊢ ofNat' (Nat.bit b n + 1) = ofNat' (Nat.bit b n) + 1

tactic: erw [ofNat'_bit true n, ofNat'_bit]
state_before: case false
α : Type ?u.180035
n : ℕ
ih : ofNat' (n + 1) = ofNat' n + 1
⊢ ofNat' (Nat.bit false n + 1) = ofNat' (Nat.bit false n) + 1

tactic: simp only [← bit1_of_bit1, ← bit0_of_bit0, cond, _root_.bit1]
state_before: case false
α : Type ?u.180035
n : ℕ
ih : ofNat' (n + 1) = ofNat' n + 1
⊢ cond true Num.bit1 Num.bit0 (ofNat' n) = cond false Num.bit1 Num.bit0 (ofNat' n) + 1

tactic: erw [show n.bit true + 1 = (n + 1).bit false by
  simp [Nat.bit, _root_.bit1, _root_.bit0]; exact Nat.add_left_comm n 1 1,
  ofNat'_bit, ofNat'_bit, ih]
state_before: case true
α : Type ?u.180035
n : ℕ
ih : ofNat' (n + 1) = ofNat' n + 1
⊢ ofNat' (Nat.bit true n + 1) = ofNat' (Nat.bit true n) + 1

tactic: simp only [cond, add_one, bit1_succ]
state_before: case true
α : Type ?u.180035
n : ℕ
ih : ofNat' (n + 1) = ofNat' n + 1
⊢ cond false Num.bit1 Num.bit0 (ofNat' n + 1) = cond true Num.bit1 Num.bit0 (ofNat' n) + 1

tactic: simp [Nat.bit, _root_.bit1, _root_.bit0]
state_before: α : Type ?u.180035
n : ℕ
ih : ofNat' (n + 1) = ofNat' n + 1
⊢ Nat.bit true n + 1 = Nat.bit false (n + 1)

tactic: exact Nat.add_left_comm n 1 1
state_before: α : Type ?u.180035
n : ℕ
ih : ofNat' (n + 1) = ofNat' n + 1
⊢ n + (1 + 1) = 1 + (n + 1)
Theorem: Matrix.det_comm'
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: nontriviality A
state_before: R : Type ?u.22368
inst✝¹¹ : CommRing R
M✝ : Type ?u.22374
inst✝¹⁰ : AddCommGroup M✝
inst✝⁹ : Module R M✝
M'✝ : Type ?u.22959
inst✝⁸ : AddCommGroup M'✝
inst✝⁷ : Module R M'✝
ι : Type ?u.23501
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M✝
A : Type u_3
inst✝⁴ : CommRing A
m : Type u_1
n : Type u_2
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
M : Matrix n m A
N M' : Matrix m n A
hMM' : M ⬝ M' = 1
hM'M : M' ⬝ M = 1
⊢ det (M ⬝ N) = det (N ⬝ M)

tactic: let e := indexEquivOfInv hMM' hM'M
state_before: R : Type ?u.22368
inst✝¹¹ : CommRing R
M✝ : Type ?u.22374
inst✝¹⁰ : AddCommGroup M✝
inst✝⁹ : Module R M✝
M'✝ : Type ?u.22959
inst✝⁸ : AddCommGroup M'✝
inst✝⁷ : Module R M'✝
ι : Type ?u.23501
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e : Basis ι R M✝
A : Type u_3
inst✝⁴ : CommRing A
m : Type u_1
n : Type u_2
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
M : Matrix n m A
N M' : Matrix m n A
hMM' : M ⬝ M' = 1
hM'M : M' ⬝ M = 1
✝ : Nontrivial A
⊢ det (M ⬝ N) = det (N ⬝ M)

tactic: rw [← det_submatrix_equiv_self e, ← submatrix_mul_equiv _ _ _ (Equiv.refl n) _, det_comm,
  submatrix_mul_equiv, Equiv.coe_refl, submatrix_id_id]
state_before: R : Type ?u.22368
inst✝¹¹ : CommRing R
M✝ : Type ?u.22374
inst✝¹⁰ : AddCommGroup M✝
inst✝⁹ : Module R M✝
M'✝ : Type ?u.22959
inst✝⁸ : AddCommGroup M'✝
inst✝⁷ : Module R M'✝
ι : Type ?u.23501
inst✝⁶ : DecidableEq ι
inst✝⁵ : Fintype ι
e✝ : Basis ι R M✝
A : Type u_3
inst✝⁴ : CommRing A
m : Type u_1
n : Type u_2
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
M : Matrix n m A
N M' : Matrix m n A
hMM' : M ⬝ M' = 1
hM'M : M' ⬝ M = 1
✝ : Nontrivial A
e : n ≃ m := indexEquivOfInv hMM' hM'M
⊢ det (M ⬝ N) = det (N ⬝ M)
Theorem: CategoryTheory.MorphismProperty.IsInvertedBy.rightOp
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: haveI := h f.op hf
state_before: C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
W : MorphismProperty C
L : Cᵒᵖ ⥤ D
h : IsInvertedBy (MorphismProperty.op W) L
X Y : C
f : X ⟶ Y
hf : W f
⊢ IsIso (L.rightOp.map f)

tactic: dsimp
state_before: C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
W : MorphismProperty C
L : Cᵒᵖ ⥤ D
h : IsInvertedBy (MorphismProperty.op W) L
X Y : C
f : X ⟶ Y
hf : W f
this : IsIso (L.map f.op)
⊢ IsIso (L.rightOp.map f)

tactic: infer_instance
state_before: C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
W : MorphismProperty C
L : Cᵒᵖ ⥤ D
h : IsInvertedBy (MorphismProperty.op W) L
X Y : C
f : X ⟶ Y
hf : W f
this : IsIso (L.map f.op)
⊢ IsIso (L.map f.op).op
Theorem: Ideal.ramificationIdx_bot
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: simp
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hn : ∀ (a : ℕ), a ∈ {n | map f ⊥ ≤ P ^ n} → a ≤ n
⊢ Nat.succ n ∈ {n | map f ⊥ ≤ P ^ n}
Theorem: EMetric.hausdorffEdist_empty
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rcases ne with ⟨x, xs⟩
state_before: ι : Sort ?u.54858
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
ne : Set.Nonempty s
⊢ hausdorffEdist s ∅ = ⊤

tactic: have : infEdist x ∅ ≤ hausdorffEdist s ∅ := infEdist_le_hausdorffEdist_of_mem xs
state_before: case intro
ι : Sort ?u.54858
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t u : Set α
Φ : α → β
x : α
xs : x ∈ s
⊢ hausdorffEdist s ∅ = ⊤

tactic: simpa using this
state_before: case intro
ι : Sort ?u.54858
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t u : Set α
Φ : α → β
x : α
xs : x ∈ s
this : infEdist x ∅ ≤ hausdorffEdist s ∅
⊢ hausdorffEdist s ∅ = ⊤
Theorem: Real.sqrt_eq_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: obtain h | h := le_or_lt 0 x
state_before: z x✝ y x : ℝ
⊢ sqrt x = x ^ (1 / 2)

tactic: rw [← mul_self_inj_of_nonneg (sqrt_nonneg _) (rpow_nonneg_of_nonneg h _), mul_self_sqrt h, ← sq,
  ← rpow_nat_cast, ← rpow_mul h]
state_before: case inl
z x✝ y x : ℝ
h : 0 ≤ x
⊢ sqrt x = x ^ (1 / 2)

tactic: norm_num
state_before: case inl
z x✝ y x : ℝ
h : 0 ≤ x
⊢ x = x ^ (1 / 2 * ↑2)

tactic: have : 1 / (2 : ℝ) * π = π / (2 : ℝ)
state_before: case inr
z x✝ y x : ℝ
h : x < 0
⊢ sqrt x = x ^ (1 / 2)

tactic: ring
state_before: case this
z x✝ y x : ℝ
h : x < 0
⊢ 1 / 2 * π = π / 2

case inr
z x✝ y x : ℝ
h : x < 0
this : 1 / 2 * π = π / 2
⊢ sqrt x = x ^ (1 / 2)

tactic: rw [sqrt_eq_zero_of_nonpos h.le, rpow_def_of_neg h, this, cos_pi_div_two, MulZeroClass.mul_zero]
state_before: case inr
z x✝ y x : ℝ
h : x < 0
this : 1 / 2 * π = π / 2
⊢ sqrt x = x ^ (1 / 2)
Theorem: Traversable.map_traverse
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: rw [map_eq_traverse_id f]
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ map f <$> traverse g x = traverse (map f ∘ g) x

tactic: refine' (comp_traverse (pure ∘ f) g x).symm.trans _
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ traverse (pure ∘ f) <$> traverse g x = traverse (map f ∘ g) x

tactic: congr
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ traverse (Comp.mk ∘ map (pure ∘ f) ∘ g) x = traverse (map f ∘ g) x

tactic: apply Comp.applicative_comp_id
state_before: case h.e_4.h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ Comp.instApplicativeComp = inst✝³
Theorem: sdiff_sdiff_sdiff_le_sdiff
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sdiff_le_iff, sdiff_le_iff, sup_left_comm, sup_sdiff_self, sup_left_comm, sdiff_sup_self,
  sup_left_comm]
state_before: ι : Type ?u.94869
α : Type u_1
β : Type ?u.94875
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ (a \ b) \ (a \ c) ≤ c \ b

tactic: exact le_sup_left
state_before: ι : Type ?u.94869
α : Type u_1
β : Type ?u.94875
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ≤ a ⊔ (b ⊔ c)
Theorem: MeasureTheory.integral_eq_zero_of_mul_right_eq_neg
File: Mathlib/MeasureTheory/Group/Integration.lean

tactic: simp_rw [← self_eq_neg ℝ E, ← integral_neg, ← hf', integral_mul_right_eq_self]
state_before: 𝕜 : Type ?u.51091
M : Type ?u.51094
α : Type ?u.51097
G : Type u_1
E : Type u_2
F : Type ?u.51106
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f : G → E
g : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulRightInvariant μ
hf' : ∀ (x : G), f (x * g) = -f x
⊢ (∫ (x : G), f x ∂μ) = 0
Theorem: SymplecticGroup.J_mem
File: Mathlib/LinearAlgebra/SymplecticGroup.lean

tactic: rw [mem_iff, J, fromBlocks_multiply, fromBlocks_transpose, fromBlocks_multiply]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
⊢ J l R ∈ symplecticGroup l R

tactic: simp
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
⊢ fromBlocks ((0 ⬝ 0 + (-1) ⬝ 1) ⬝ 0ᵀ + (0 ⬝ (-1) + (-1) ⬝ 0) ⬝ (-1)ᵀ)
      ((0 ⬝ 0 + (-1) ⬝ 1) ⬝ 1ᵀ + (0 ⬝ (-1) + (-1) ⬝ 0) ⬝ 0ᵀ) ((1 ⬝ 0 + 0 ⬝ 1) ⬝ 0ᵀ + (1 ⬝ (-1) + 0 ⬝ 0) ⬝ (-1)ᵀ)
      ((1 ⬝ 0 + 0 ⬝ 1) ⬝ 1ᵀ + (1 ⬝ (-1) + 0 ⬝ 0) ⬝ 0ᵀ) =
    fromBlocks 0 (-1) 1 0
Theorem: LaurentPolynomial.degree_C_le
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: rw [T_zero, mul_one]
state_before: R : Type u_1
inst✝ : Semiring R
a : R
⊢ degree (↑C a) = degree (↑C a * T 0)
Theorem: BoxIntegral.Box.withBotCoe_subset_iff
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: induction I using WithBot.recBotCoe
state_before: ι : Type u_1
I✝ J✝ : Box ι
x y : ι → ℝ
I J : WithBot (Box ι)
⊢ ↑I ⊆ ↑J ↔ I ≤ J

tactic: induction J using WithBot.recBotCoe
state_before: case coe
ι : Type u_1
I J✝ : Box ι
x y : ι → ℝ
J : WithBot (Box ι)
a✝ : Box ι
⊢ ↑↑a✝ ⊆ ↑J ↔ ↑a✝ ≤ J

tactic: simp [le_def]
state_before: case coe.coe
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝¹ a✝ : Box ι
⊢ ↑↑a✝¹ ⊆ ↑↑a✝ ↔ ↑a✝¹ ≤ ↑a✝

tactic: simp
state_before: case bot
ι : Type u_1
I J✝ : Box ι
x y : ι → ℝ
J : WithBot (Box ι)
⊢ ↑⊥ ⊆ ↑J ↔ ⊥ ≤ J

tactic: simp [subset_empty_iff]
state_before: case coe.bot
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝ : Box ι
⊢ ↑↑a✝ ⊆ ↑⊥ ↔ ↑a✝ ≤ ⊥
Theorem: Cardinal.range_natCast
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp only [mem_Iio, mem_range, eq_comm, lt_aleph0]
state_before: α β : Type u
x : Cardinal
⊢ x ∈ range Nat.cast ↔ x ∈ Iio ℵ₀
Theorem: CategoryTheory.MonoidalClosed.uncurry_id_eq_ev
File: Mathlib/CategoryTheory/Closed/Monoidal.lean

tactic: rw [uncurry_eq, tensor_id, id_comp]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : MonoidalCategory C
A B X X' Y Y' Z : C
inst✝ : Closed A
⊢ uncurry (𝟙 ((ihom A).obj X)) = (ihom.ev A).app X
Theorem: Fin.castSucc_eq_zero_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: simp
state_before: n m : ℕ
inst✝ : NeZero n
a : Fin n
⊢ ↑a = ↑0 ↔ ↑(↑castSucc a) = ↑0
Theorem: Nat.one_div_le_one_div
File: Mathlib/Data/Nat/Cast/Field.lean

tactic: refine' one_div_le_one_div_of_le _ _
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n ≤ m
⊢ 1 / (↑m + 1) ≤ 1 / (↑n + 1)

tactic: exact Nat.cast_add_one_pos _
state_before: case refine'_1
α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n ≤ m
⊢ 0 < ↑n + 1

case refine'_2
α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n ≤ m
⊢ ↑n + 1 ≤ ↑m + 1

tactic: simpa
state_before: case refine'_2
α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n ≤ m
⊢ ↑n + 1 ≤ ↑m + 1
Theorem: CategoryTheory.Limits.limit.post_post
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: haveI : HasLimit (F ⋙  G ⋙  H) := h
state_before: J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
D : Type u'
inst✝³ : Category D
inst✝² : HasLimit F
G : C ⥤ D
inst✝¹ : HasLimit (F ⋙ G)
E : Type u''
inst✝ : Category E
H : D ⥤ E
h : HasLimit ((F ⋙ G) ⋙ H)
⊢ H.map (post F G) ≫ post (F ⋙ G) H = post F (G ⋙ H)

tactic: ext
state_before: J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
D : Type u'
inst✝³ : Category D
inst✝² : HasLimit F
G : C ⥤ D
inst✝¹ : HasLimit (F ⋙ G)
E : Type u''
inst✝ : Category E
H : D ⥤ E
h : HasLimit ((F ⋙ G) ⋙ H)
this : HasLimit (F ⋙ G ⋙ H)
⊢ H.map (post F G) ≫ post (F ⋙ G) H = post F (G ⋙ H)

tactic: erw [assoc, limit.post_π, ← H.map_comp, limit.post_π, limit.post_π]
state_before: case w
J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
D : Type u'
inst✝³ : Category D
inst✝² : HasLimit F
G : C ⥤ D
inst✝¹ : HasLimit (F ⋙ G)
E : Type u''
inst✝ : Category E
H : D ⥤ E
h : HasLimit ((F ⋙ G) ⋙ H)
this : HasLimit (F ⋙ G ⋙ H)
j✝ : J
⊢ (H.map (post F G) ≫ post (F ⋙ G) H) ≫ π ((F ⋙ G) ⋙ H) j✝ = post F (G ⋙ H) ≫ π ((F ⋙ G) ⋙ H) j✝

tactic: rfl
state_before: case w
J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
D : Type u'
inst✝³ : Category D
inst✝² : HasLimit F
G : C ⥤ D
inst✝¹ : HasLimit (F ⋙ G)
E : Type u''
inst✝ : Category E
H : D ⥤ E
h : HasLimit ((F ⋙ G) ⋙ H)
this : HasLimit (F ⋙ G ⋙ H)
j✝ : J
⊢ H.map (G.map (π F j✝)) = (G ⋙ H).map (π F j✝)
Theorem: CategoryTheory.Limits.colimit.pre_map
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: ext
state_before: J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F : J ⥤ C
inst✝¹ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
inst✝ : HasColimitsOfShape K C
E : K ⥤ J
⊢ pre F E ≫ colim.map α = colim.map (whiskerLeft E α) ≫ pre G E

tactic: rw [← assoc, colimit.ι_pre, colimit.ι_map, ← assoc, colimit.ι_map, assoc, colimit.ι_pre]
state_before: case w
J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F : J ⥤ C
inst✝¹ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
inst✝ : HasColimitsOfShape K C
E : K ⥤ J
j✝ : K
⊢ ι (E ⋙ F) j✝ ≫ pre F E ≫ colim.map α = ι (E ⋙ F) j✝ ≫ colim.map (whiskerLeft E α) ≫ pre G E

tactic: rfl
state_before: case w
J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F : J ⥤ C
inst✝¹ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
inst✝ : HasColimitsOfShape K C
E : K ⥤ J
j✝ : K
⊢ α.app (E.obj j✝) ≫ ι G (E.obj j✝) = (whiskerLeft E α).app j✝ ≫ ι G (E.obj j✝)
Theorem: CategoryTheory.Iso.ext
File: Mathlib/CategoryTheory/Iso.lean

tactic: cases α
state_before: C : Type u
inst✝ : Category C
X Y Z : C
α β : X ≅ Y
w : α.hom = β.hom
this : α.inv = β.inv
⊢ α = β

tactic: cases β
state_before: case mk
C : Type u
inst✝ : Category C
X Y Z : C
β : X ≅ Y
hom✝ : X ⟶ Y
inv✝ : Y ⟶ X
hom_inv_id✝ : hom✝ ≫ inv✝ = 𝟙 X
inv_hom_id✝ : inv✝ ≫ hom✝ = 𝟙 Y
w : (mk hom✝ inv✝).hom = β.hom
this : (mk hom✝ inv✝).inv = β.inv
⊢ mk hom✝ inv✝ = β

tactic: cases w
state_before: case mk.mk
C : Type u
inst✝ : Category C
X Y Z : C
hom✝¹ : X ⟶ Y
inv✝¹ : Y ⟶ X
hom_inv_id✝¹ : hom✝¹ ≫ inv✝¹ = 𝟙 X
inv_hom_id✝¹ : inv✝¹ ≫ hom✝¹ = 𝟙 Y
hom✝ : X ⟶ Y
inv✝ : Y ⟶ X
hom_inv_id✝ : hom✝ ≫ inv✝ = 𝟙 X
inv_hom_id✝ : inv✝ ≫ hom✝ = 𝟙 Y
w : (mk hom✝¹ inv✝¹).hom = (mk hom✝ inv✝).hom
this : (mk hom✝¹ inv✝¹).inv = (mk hom✝ inv✝).inv
⊢ mk hom✝¹ inv✝¹ = mk hom✝ inv✝

tactic: cases this
state_before: case mk.mk.refl
C : Type u
inst✝ : Category C
X Y Z : C
hom✝ : X ⟶ Y
inv✝¹ : Y ⟶ X
hom_inv_id✝¹ : hom✝ ≫ inv✝¹ = 𝟙 X
inv_hom_id✝¹ : inv✝¹ ≫ hom✝ = 𝟙 Y
inv✝ : Y ⟶ X
hom_inv_id✝ : hom✝ ≫ inv✝ = 𝟙 X
inv_hom_id✝ : inv✝ ≫ hom✝ = 𝟙 Y
this : (mk hom✝ inv✝¹).inv = (mk hom✝ inv✝).inv
⊢ mk hom✝ inv✝¹ = mk hom✝ inv✝

tactic: rfl
state_before: case mk.mk.refl.refl
C : Type u
inst✝ : Category C
X Y Z : C
hom✝ : X ⟶ Y
inv✝ : Y ⟶ X
hom_inv_id✝¹ : hom✝ ≫ inv✝ = 𝟙 X
inv_hom_id✝¹ : inv✝ ≫ hom✝ = 𝟙 Y
hom_inv_id✝ : hom✝ ≫ inv✝ = 𝟙 X
inv_hom_id✝ : inv✝ ≫ hom✝ = 𝟙 Y
⊢ mk hom✝ inv✝ = mk hom✝ inv✝

tactic: rw [Iso.hom_inv_id, Category.comp_id]
state_before: C : Type u
inst✝ : Category C
X Y Z : C
α β : X ≅ Y
w : α.hom = β.hom
⊢ α.inv = α.inv ≫ β.hom ≫ β.inv

tactic: rw [Category.assoc, ← w]
state_before: C : Type u
inst✝ : Category C
X Y Z : C
α β : X ≅ Y
w : α.hom = β.hom
⊢ α.inv ≫ β.hom ≫ β.inv = (α.inv ≫ α.hom) ≫ β.inv

tactic: rw [Iso.inv_hom_id, Category.id_comp]
state_before: C : Type u
inst✝ : Category C
X Y Z : C
α β : X ≅ Y
w : α.hom = β.hom
⊢ (α.inv ≫ α.hom) ≫ β.inv = β.inv
Theorem: Cycle.nontrivial_reverse_iff
File: Mathlib/Data/List/Cycle.lean

tactic: simp [Nontrivial]
state_before: α : Type u_1
s : Cycle α
⊢ Nontrivial (reverse s) ↔ Nontrivial s