tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.tensorLeftHomEquiv_id_tensor_comp_evaluation
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: dsimp [tensorLeftHomEquiv]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
Y Z : C
inst✝ : HasLeftDual Z
f : Y ⟶ ᘁZ
⊢ ↑(tensorLeftHomEquiv Y (ᘁZ) Z (𝟙_ C)) ((𝟙 Z ⊗ f) ≫ ε_ (ᘁZ) Z) = f ≫ (ρ_ ᘁZ).inv

tactic: rw [id_tensor_comp]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
Y Z : C
inst✝ : HasLeftDual Z
f : Y ⟶ ᘁZ
⊢ (λ_ Y).inv ≫ (η_ (ᘁZ) Z ⊗ 𝟙 Y) ≫ (α_ (ᘁZ) Z Y).hom ≫ (𝟙 ᘁZ ⊗ (𝟙 Z ⊗ f) ≫ ε_ (ᘁZ) Z) = f ≫ (ρ_ ᘁZ).inv

tactic: slice_lhs 3 4 => rw [← associator_naturality]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
Y Z : C
inst✝ : HasLeftDual Z
f : Y ⟶ ᘁZ
⊢ (λ_ Y).inv ≫ (η_ (ᘁZ) Z ⊗ 𝟙 Y) ≫ (α_ (ᘁZ) Z Y).hom ≫ (𝟙 ᘁZ ⊗ 𝟙 Z ⊗ f) ≫ (𝟙 ᘁZ ⊗ ε_ (ᘁZ) Z) = f ≫ (ρ_ ᘁZ).inv

tactic: slice_lhs 2 3 => rw [tensor_id, tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
Y Z : C
inst✝ : HasLeftDual Z
f : Y ⟶ ᘁZ
⊢ (λ_ Y).inv ≫ (η_ (ᘁZ) Z ⊗ 𝟙 Y) ≫ (((𝟙 ᘁZ ⊗ 𝟙 Z) ⊗ f) ≫ (α_ (ᘁZ) Z ᘁZ).hom) ≫ (𝟙 ᘁZ ⊗ ε_ (ᘁZ) Z) = f ≫ (ρ_ ᘁZ).inv

tactic: slice_lhs 3 5 => rw [evaluation_coevaluation]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
Y Z : C
inst✝ : HasLeftDual Z
f : Y ⟶ ᘁZ
⊢ (λ_ Y).inv ≫ (((𝟙 tensorUnit' ⊗ f) ≫ (η_ (ᘁZ) Z ⊗ 𝟙 ᘁZ)) ≫ (α_ (ᘁZ) Z ᘁZ).hom) ≫ (𝟙 ᘁZ ⊗ ε_ (ᘁZ) Z) = f ≫ (ρ_ ᘁZ).inv

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
Y Z : C
inst✝ : HasLeftDual Z
f : Y ⟶ ᘁZ
⊢ (λ_ Y).inv ≫ (𝟙 tensorUnit' ⊗ f) ≫ (λ_ ᘁZ).hom ≫ (ρ_ ᘁZ).inv = f ≫ (ρ_ ᘁZ).inv
Theorem: NonemptyInterval.mul_eq_one_iff
File: Mathlib/Algebra/Order/Interval.lean

tactic: refine' ⟨fun h => _, _⟩
state_before: ι : Type ?u.338842
α : Type u_1
inst✝ : OrderedCommGroup α
s t : NonemptyInterval α
⊢ s * t = 1 ↔ ∃ a b, s = pure a ∧ t = pure b ∧ a * b = 1

tactic: rw [ext_iff, Prod.ext_iff] at h
state_before: case refine'_1
ι : Type ?u.338842
α : Type u_1
inst✝ : OrderedCommGroup α
s t : NonemptyInterval α
h : s * t = 1
⊢ ∃ a b, s = pure a ∧ t = pure b ∧ a * b = 1

tactic: have := (mul_le_mul_iff_of_ge s.fst_le_snd t.fst_le_snd).1 (h.2.trans h.1.symm).le
state_before: case refine'_1
ι : Type ?u.338842
α : Type u_1
inst✝ : OrderedCommGroup α
s t : NonemptyInterval α
h : (s * t).fst = 1.fst ∧ (s * t).snd = 1.snd
⊢ ∃ a b, s = pure a ∧ t = pure b ∧ a * b = 1

tactic: refine' ⟨s.fst, t.fst, _, _, h.1⟩ <;> apply NonemptyInterval.ext <;> dsimp [pure]
state_before: case refine'_1
ι : Type ?u.338842
α : Type u_1
inst✝ : OrderedCommGroup α
s t : NonemptyInterval α
h : (s * t).fst = 1.fst ∧ (s * t).snd = 1.snd
this : s.fst = s.snd ∧ t.fst = t.snd
⊢ ∃ a b, s = pure a ∧ t = pure b ∧ a * b = 1

tactic: nth_rw 2 [this.1]
state_before: case refine'_1.refine'_1.h
ι : Type ?u.338842
α : Type u_1
inst✝ : OrderedCommGroup α
s t : NonemptyInterval α
h : (s * t).fst = 1.fst ∧ (s * t).snd = 1.snd
this : s.fst = s.snd ∧ t.fst = t.snd
⊢ s.toProd = (s.fst, s.fst)

tactic: nth_rw 2 [this.2]
state_before: case refine'_1.refine'_2.h
ι : Type ?u.338842
α : Type u_1
inst✝ : OrderedCommGroup α
s t : NonemptyInterval α
h : (s * t).fst = 1.fst ∧ (s * t).snd = 1.snd
this : s.fst = s.snd ∧ t.fst = t.snd
⊢ t.toProd = (t.fst, t.fst)

tactic: rintro ⟨b, c, rfl, rfl, h⟩
state_before: case refine'_2
ι : Type ?u.338842
α : Type u_1
inst✝ : OrderedCommGroup α
s t : NonemptyInterval α
⊢ (∃ a b, s = pure a ∧ t = pure b ∧ a * b = 1) → s * t = 1

tactic: rw [pure_mul_pure, h, pure_one]
state_before: case refine'_2.intro.intro.intro.intro
ι : Type ?u.338842
α : Type u_1
inst✝ : OrderedCommGroup α
b c : α
h : b * c = 1
⊢ pure b * pure c = 1
Theorem: Int.gcd_div_gcd_div_gcd
File: Mathlib/Data/Int/GCD.lean

tactic: rw [gcd_div (gcd_dvd_left i j) (gcd_dvd_right i j), natAbs_ofNat, Nat.div_self H]
state_before: i j : ℤ
H : 0 < gcd i j
⊢ gcd (i / ↑(gcd i j)) (j / ↑(gcd i j)) = 1
Theorem: unitInterval.two_mul_sub_one_mem_iff
File: Mathlib/Topology/UnitInterval.lean

tactic: constructor <;> rintro ⟨h₁, h₂⟩ <;> constructor <;> linarith
state_before: t : ℝ
⊢ 2 * t - 1 ∈ I ↔ t ∈ Icc (1 / 2) 1
Theorem: exists_eq_left'
File: Std/Logic.lean

tactic: simp [@eq_comm _ a']
state_before: α : Sort u_1
p q : α → Prop
b : Prop
a' : α
⊢ (∃ a, a' = a ∧ p a) ↔ p a'
Theorem: MvQPF.suppPreservation_iff_isUniform
File: Mathlib/Data/QPF/Multivariate/Basic.lean

tactic: constructor
state_before: n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
⊢ SuppPreservation ↔ IsUniform

tactic: intro h α a a' f f' h' i
state_before: case mp
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
⊢ SuppPreservation → IsUniform

tactic: rw [← MvPFunctor.supp_eq, ← MvPFunctor.supp_eq, ← h, h', h]
state_before: case mp
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : SuppPreservation
α : TypeVec n
a a' : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
f' : MvPFunctor.B (P F) a' ⟹ α
h' : abs { fst := a, snd := f } = abs { fst := a', snd := f' }
i : Fin2 n
⊢ f i '' univ = f' i '' univ

tactic: rintro h α ⟨a, f⟩
state_before: case mpr
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
⊢ IsUniform → SuppPreservation

tactic: ext
state_before: case mpr.mk
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
⊢ supp (abs { fst := a, snd := f }) = supp { fst := a, snd := f }

tactic: rwa [supp_eq_of_isUniform, MvPFunctor.supp_eq]
state_before: case mpr.mk.h.h
n : ℕ
F : TypeVec n → Type u_1
inst✝ : MvFunctor F
q : MvQPF F
h : IsUniform
α : TypeVec n
a : (P F).A
f : MvPFunctor.B (P F) a ⟹ α
x✝¹ : Fin2 n
x✝ : α x✝¹
⊢ x✝ ∈ supp (abs { fst := a, snd := f }) x✝¹ ↔ x✝ ∈ supp { fst := a, snd := f } x✝¹
Theorem: Num.add_toZNum
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases m <;> cases n <;> rfl
state_before: α : Type ?u.456739
m n : Num
⊢ toZNum (m + n) = toZNum m + toZNum n
Theorem: LieHom.mk_coe
File: Mathlib/Algebra/Lie/Basic.lean

tactic: ext
state_before: R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
h₁ : ∀ (x y : L₁), ↑f (x + y) = ↑f x + ↑f y
h₂ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := ↑f, map_add' := h₁ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := ↑f, map_add' := h₁ } x
h₃ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }.toAddHom y⁆
⊢ { toLinearMap := { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }, map_lie' := h₃ } = f

tactic: rfl
state_before: case h
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
h₁ : ∀ (x y : L₁), ↑f (x + y) = ↑f x + ↑f y
h₂ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := ↑f, map_add' := h₁ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := ↑f, map_add' := h₁ } x
h₃ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }.toAddHom y⁆
x✝ : L₁
⊢ ↑{ toLinearMap := { toAddHom := { toFun := ↑f, map_add' := h₁ }, map_smul' := h₂ }, map_lie' := h₃ } x✝ = ↑f x✝
Theorem: MonoidHom.map_neg
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: rw [← neg_one_mul, map_mul, map_neg_one, one_mul]
state_before: β : Type ?u.296855
A : Type ?u.296858
G : Type ?u.296861
M : Type u_1
R : Type u_2
inst✝³ : Ring R
inst✝² : Monoid M
inst✝¹ : LinearOrder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
f : R →* M
x : R
⊢ ↑f (-x) = ↑f x
Theorem: MeasureTheory.Measure.toSignedMeasure_eq_toSignedMeasure_iff
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: refine' ⟨fun h => _, fun h => _⟩
state_before: α : Type u_1
β : Type ?u.135386
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
⊢ toSignedMeasure μ = toSignedMeasure ν ↔ μ = ν

tactic: ext1 i hi
state_before: case refine'_1
α : Type u_1
β : Type ?u.135386
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : toSignedMeasure μ = toSignedMeasure ν
⊢ μ = ν

tactic: have : μ.toSignedMeasure i = ν.toSignedMeasure i := by rw [h]
state_before: case refine'_1.h
α : Type u_1
β : Type ?u.135386
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : toSignedMeasure μ = toSignedMeasure ν
i : Set α
hi : MeasurableSet i
⊢ ↑↑μ i = ↑↑ν i

tactic: rwa [toSignedMeasure_apply_measurable hi, toSignedMeasure_apply_measurable hi,
    ENNReal.toReal_eq_toReal] at this
  <;> exact measure_ne_top _ _
state_before: case refine'_1.h
α : Type u_1
β : Type ?u.135386
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : toSignedMeasure μ = toSignedMeasure ν
i : Set α
hi : MeasurableSet i
this : ↑(toSignedMeasure μ) i = ↑(toSignedMeasure ν) i
⊢ ↑↑μ i = ↑↑ν i

tactic: rw [h]
state_before: α : Type u_1
β : Type ?u.135386
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : toSignedMeasure μ = toSignedMeasure ν
i : Set α
hi : MeasurableSet i
⊢ ↑(toSignedMeasure μ) i = ↑(toSignedMeasure ν) i

tactic: congr
state_before: case refine'_2
α : Type u_1
β : Type ?u.135386
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : μ = ν
⊢ toSignedMeasure μ = toSignedMeasure ν
Theorem: Group.conjugates_subset_normal
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rintro a hc
state_before: G : Type u_1
G' : Type ?u.435622
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.435631
inst✝ : AddGroup A
s : Set G
N : Subgroup G
tn : Subgroup.Normal N
a : G
h : a ∈ N
⊢ conjugatesOf a ⊆ ↑N

tactic: obtain ⟨c, rfl⟩ := isConj_iff.1 hc
state_before: G : Type u_1
G' : Type ?u.435622
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.435631
inst✝ : AddGroup A
s : Set G
N : Subgroup G
tn : Subgroup.Normal N
a✝ : G
h : a✝ ∈ N
a : G
hc : a ∈ conjugatesOf a✝
⊢ a ∈ ↑N

tactic: exact tn.conj_mem a h c
state_before: case intro
G : Type u_1
G' : Type ?u.435622
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.435631
inst✝ : AddGroup A
s : Set G
N : Subgroup G
tn : Subgroup.Normal N
a : G
h : a ∈ N
c : G
hc : c * a * c⁻¹ ∈ conjugatesOf a
⊢ c * a * c⁻¹ ∈ ↑N
Theorem: Primrec.option_some
File: Mathlib/Computability/Primrec.lean

tactic: cases @decode α _ n <;> simp
state_before: α : Type u_1
β : Type ?u.21098
σ : Type ?u.21101
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
n : ℕ
⊢ (Nat.casesOn (encode (decode n)) 0 fun n => Nat.succ (Nat.succ n)) = encode (Option.map some (decode n))
Theorem: Equiv.Perm.decomposeOption_symm_sign
File: Mathlib/GroupTheory/Perm/Option.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
e : Perm α
⊢ ↑sign (↑decomposeOption.symm (none, e)) = ↑sign e
Theorem: sup_himp_self_right
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sup_himp_distrib, himp_self, inf_top_eq]
state_before: ι : Type ?u.72997
α : Type u_1
β : Type ?u.73003
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c d a b : α
⊢ a ⊔ b ⇨ b = a ⇨ b
Theorem: Equiv.mulEquiv_symm_apply
File: Mathlib/Logic/Equiv/TransferInstance.lean

tactic: intros
state_before: α : Type u
β : Type v
e✝ e : α ≃ β
inst✝ : Mul β
b : β
⊢ ↑(MulEquiv.symm (mulEquiv e)) b = ↑e.symm b

tactic: rfl
state_before: α : Type u
β : Type v
e✝ e : α ≃ β
inst✝ : Mul β
b : β
⊢ ↑(MulEquiv.symm (mulEquiv e)) b = ↑e.symm b
Theorem: EReal.toReal_neg
File: Mathlib/Data/Real/EReal.lean

tactic: simp
state_before: ⊢ toReal (-⊤) = -toReal ⊤

tactic: simp
state_before: ⊢ toReal (-⊥) = -toReal ⊥
Theorem: dist_one_left
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [dist_comm, dist_one_right]
state_before: 𝓕 : Type ?u.50544
𝕜 : Type ?u.50547
α : Type ?u.50550
ι : Type ?u.50553
κ : Type ?u.50556
E : Type u_1
F : Type ?u.50562
G : Type ?u.50565
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
a : E
⊢ dist 1 a = ‖a‖
Theorem: sameRay_iff_inv_norm_smul_eq
File: Mathlib/Analysis/NormedSpace/Ray.lean

tactic: rcases eq_or_ne x 0 with (rfl | hx)
state_before: E : Type ?u.236691
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : F
⊢ SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ ‖x‖⁻¹ • x = ‖y‖⁻¹ • y

tactic: rcases eq_or_ne y 0 with (rfl | hy)
state_before: case inr
E : Type ?u.236691
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : F
hx : x ≠ 0
⊢ SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ ‖x‖⁻¹ • x = ‖y‖⁻¹ • y

tactic: simp only [sameRay_iff_inv_norm_smul_eq_of_ne hx hy, *, false_or_iff]
state_before: case inr.inr
E : Type ?u.236691
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : F
hx : x ≠ 0
hy : y ≠ 0
⊢ SameRay ℝ x y ↔ x = 0 ∨ y = 0 ∨ ‖x‖⁻¹ • x = ‖y‖⁻¹ • y

tactic: simp [SameRay.zero_left]
state_before: case inl
E : Type ?u.236691
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
y : F
⊢ SameRay ℝ 0 y ↔ 0 = 0 ∨ y = 0 ∨ ‖0‖⁻¹ • 0 = ‖y‖⁻¹ • y

tactic: simp [SameRay.zero_right]
state_before: case inr.inl
E : Type ?u.236691
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x : F
hx : x ≠ 0
⊢ SameRay ℝ x 0 ↔ x = 0 ∨ 0 = 0 ∨ ‖x‖⁻¹ • x = ‖0‖⁻¹ • 0
Theorem: measurableSet_prod_of_nonempty
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: rcases h with ⟨⟨x, y⟩, hx, hy⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.83086
δ : Type ?u.83089
δ' : Type ?u.83092
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
s : Set α
t : Set β
h : Set.Nonempty (s ×ˢ t)
⊢ MeasurableSet (s ×ˢ t) ↔ MeasurableSet s ∧ MeasurableSet t

tactic: refine' ⟨fun hst => _, fun h => h.1.prod h.2⟩
state_before: case intro.mk.intro
α : Type u_1
β : Type u_2
γ : Type ?u.83086
δ : Type ?u.83089
δ' : Type ?u.83092
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
s : Set α
t : Set β
x : α
y : β
hx : (x, y).fst ∈ s
hy : (x, y).snd ∈ t
⊢ MeasurableSet (s ×ˢ t) ↔ MeasurableSet s ∧ MeasurableSet t

tactic: have : MeasurableSet ((fun x => (x, y)) ⁻¹' s ×ˢ t) := measurable_prod_mk_right hst
state_before: case intro.mk.intro
α : Type u_1
β : Type u_2
γ : Type ?u.83086
δ : Type ?u.83089
δ' : Type ?u.83092
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
s : Set α
t : Set β
x : α
y : β
hx : (x, y).fst ∈ s
hy : (x, y).snd ∈ t
hst : MeasurableSet (s ×ˢ t)
⊢ MeasurableSet s ∧ MeasurableSet t

tactic: have : MeasurableSet (Prod.mk x ⁻¹' s ×ˢ t) := measurable_prod_mk_left hst
state_before: case intro.mk.intro
α : Type u_1
β : Type u_2
γ : Type ?u.83086
δ : Type ?u.83089
δ' : Type ?u.83092
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
s : Set α
t : Set β
x : α
y : β
hx : (x, y).fst ∈ s
hy : (x, y).snd ∈ t
hst : MeasurableSet (s ×ˢ t)
this : MeasurableSet ((fun x => (x, y)) ⁻¹' s ×ˢ t)
⊢ MeasurableSet s ∧ MeasurableSet t

tactic: simp_all
state_before: case intro.mk.intro
α : Type u_1
β : Type u_2
γ : Type ?u.83086
δ : Type ?u.83089
δ' : Type ?u.83092
ι : Sort uι
s✝ t✝ u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
s : Set α
t : Set β
x : α
y : β
hx : (x, y).fst ∈ s
hy : (x, y).snd ∈ t
hst : MeasurableSet (s ×ˢ t)
this✝ : MeasurableSet ((fun x => (x, y)) ⁻¹' s ×ˢ t)
this : MeasurableSet (Prod.mk x ⁻¹' s ×ˢ t)
⊢ MeasurableSet s ∧ MeasurableSet t
Theorem: codisjoint_inf_right
File: Mathlib/Order/Disjoint.lean

tactic: simp only [codisjoint_iff, sup_inf_left, inf_eq_top_iff]
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderTop α
a b c : α
⊢ Codisjoint a (b ⊓ c) ↔ Codisjoint a b ∧ Codisjoint a c
Theorem: FirstOrder.Language.Embedding.comp_toHom
File: Mathlib/ModelTheory/Basic.lean

tactic: ext
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : Structure L M
inst✝² : Structure L N
P : Type u_1
inst✝¹ : Structure L P
Q : Type ?u.151174
inst✝ : Structure L Q
hnp : N ↪[L] P
hmn : M ↪[L] N
⊢ toHom (comp hnp hmn) = Hom.comp (toHom hnp) (toHom hmn)

tactic: simp only [coe_toHom, comp_apply, Hom.comp_apply]
state_before: case h
L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : Structure L M
inst✝² : Structure L N
P : Type u_1
inst✝¹ : Structure L P
Q : Type ?u.151174
inst✝ : Structure L Q
hnp : N ↪[L] P
hmn : M ↪[L] N
x✝ : M
⊢ ↑(toHom (comp hnp hmn)) x✝ = ↑(Hom.comp (toHom hnp) (toHom hmn)) x✝
Theorem: isLUB_prod
File: Mathlib/Order/Bounds/Basic.lean

tactic: refine'
  ⟨fun H =>
    ⟨⟨monotone_fst.mem_upperBounds_image H.1, fun a ha => _⟩,
      ⟨monotone_snd.mem_upperBounds_image H.1, fun a ha => _⟩⟩,
    fun H => ⟨_, _⟩⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set (α × β)
p : α × β
⊢ IsLUB s p ↔ IsLUB (Prod.fst '' s) p.fst ∧ IsLUB (Prod.snd '' s) p.snd

tactic: suffices h : (a, p.2) ∈ upperBounds s from (H.2 h).1
state_before: case refine'_1
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set (α × β)
p : α × β
H : IsLUB s p
a : α
ha : a ∈ upperBounds (Prod.fst '' s)
⊢ p.fst ≤ a

tactic: exact fun q hq => ⟨ha <| mem_image_of_mem _ hq, (H.1 hq).2⟩
state_before: case refine'_1
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set (α × β)
p : α × β
H : IsLUB s p
a : α
ha : a ∈ upperBounds (Prod.fst '' s)
⊢ (a, p.snd) ∈ upperBounds s

tactic: suffices h : (p.1, a) ∈ upperBounds s from (H.2 h).2
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set (α × β)
p : α × β
H : IsLUB s p
a : β
ha : a ∈ upperBounds (Prod.snd '' s)
⊢ p.snd ≤ a

tactic: exact fun q hq => ⟨(H.1 hq).1, ha <| mem_image_of_mem _ hq⟩
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set (α × β)
p : α × β
H : IsLUB s p
a : β
ha : a ∈ upperBounds (Prod.snd '' s)
⊢ (p.fst, a) ∈ upperBounds s

tactic: exact fun q hq => ⟨H.1.1 <| mem_image_of_mem _ hq, H.2.1 <| mem_image_of_mem _ hq⟩
state_before: case refine'_3
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set (α × β)
p : α × β
H : IsLUB (Prod.fst '' s) p.fst ∧ IsLUB (Prod.snd '' s) p.snd
⊢ p ∈ upperBounds s

tactic: exact fun q hq =>
  ⟨H.1.2 <| monotone_fst.mem_upperBounds_image hq,
    H.2.2 <| monotone_snd.mem_upperBounds_image hq⟩
state_before: case refine'_4
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set (α × β)
p : α × β
H : IsLUB (Prod.fst '' s) p.fst ∧ IsLUB (Prod.snd '' s) p.snd
⊢ p ∈ lowerBounds (upperBounds s)
Theorem: CategoryTheory.MonoidalCategory.tensorLeftTensor_inv_app
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: simp [tensorLeftTensor]
state_before: C✝¹ : Type u
𝒞 : Category C✝¹
inst✝⁴ : MonoidalCategory C✝¹
C✝ : Type u
inst✝³ : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
X Y Z : C
⊢ (tensorLeftTensor X Y).inv.app Z = (α_ X Y Z).inv
Theorem: DirectSum.decompose_of_mem_ne
File: Mathlib/Algebra/DirectSum/Decomposition.lean

tactic: rw [decompose_of_mem _ hx, DirectSum.of_eq_of_ne _ _ _ _ hij, ZeroMemClass.coe_zero]
state_before: ι : Type u_3
R : Type ?u.124931
M : Type u_1
σ : Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : AddCommMonoid M
inst✝² : SetLike σ M
inst✝¹ : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝ : Decomposition ℳ
x : M
i j : ι
hx : x ∈ ℳ i
hij : i ≠ j
⊢ ↑(↑(↑(decompose ℳ) x) j) = 0
Theorem: PGame.lf_iff_lt_or_fuzzy
File: Mathlib/SetTheory/Game/PGame.lean

tactic: simp only [lt_iff_le_and_lf, Fuzzy, ← PGame.not_le]
state_before: x y : PGame
⊢ x ⧏ y ↔ x < y ∨ x ‖ y

tactic: tauto
state_before: x y : PGame
⊢ ¬y ≤ x ↔ x ≤ y ∧ ¬y ≤ x ∨ ¬y ≤ x ∧ ¬x ≤ y
Theorem: isIntegral_algHom_iff
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: refine' ⟨_, map_isIntegral f⟩
state_before: R : Type u_3
A✝ : Type ?u.158436
B✝ : Type ?u.158439
S : Type ?u.158442
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A✝
inst✝⁷ : CommRing B✝
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R A✝
inst✝⁴ : Algebra R B✝
f✝ : R →+* S
A : Type u_1
B : Type u_2
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : A →ₐ[R] B
hf : Function.Injective ↑f
x : A
⊢ IsIntegral R (↑f x) ↔ IsIntegral R x

tactic: rintro ⟨p, hp, hx⟩
state_before: R : Type u_3
A✝ : Type ?u.158436
B✝ : Type ?u.158439
S : Type ?u.158442
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A✝
inst✝⁷ : CommRing B✝
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R A✝
inst✝⁴ : Algebra R B✝
f✝ : R →+* S
A : Type u_1
B : Type u_2
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : A →ₐ[R] B
hf : Function.Injective ↑f
x : A
⊢ IsIntegral R (↑f x) → IsIntegral R x

tactic: use p, hp
state_before: case intro.intro
R : Type u_3
A✝ : Type ?u.158436
B✝ : Type ?u.158439
S : Type ?u.158442
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A✝
inst✝⁷ : CommRing B✝
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R A✝
inst✝⁴ : Algebra R B✝
f✝ : R →+* S
A : Type u_1
B : Type u_2
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : A →ₐ[R] B
hf : Function.Injective ↑f
x : A
p : R[X]
hp : Monic p
hx : eval₂ (algebraMap R ((fun x => B) x)) (↑f x) p = 0
⊢ IsIntegral R x

tactic: rwa [← f.comp_algebraMap, ← AlgHom.coe_toRingHom, ← Polynomial.hom_eval₂, AlgHom.coe_toRingHom,
  map_eq_zero_iff f hf] at hx
state_before: case intro.intro
R : Type u_3
A✝ : Type ?u.158436
B✝ : Type ?u.158439
S : Type ?u.158442
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A✝
inst✝⁷ : CommRing B✝
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R A✝
inst✝⁴ : Algebra R B✝
f✝ : R →+* S
A : Type u_1
B : Type u_2
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : A →ₐ[R] B
hf : Function.Injective ↑f
x : A
p : R[X]
hp : Monic p
hx : eval₂ (algebraMap R ((fun x => B) x)) (↑f x) p = 0
⊢ eval₂ (algebraMap R A) x p = 0
Theorem: Bifunctor.fst_snd
File: Mathlib/Control/Bifunctor.lean

tactic: simp [fst, bimap_bimap]
state_before: F : Type u₀ → Type u₁ → Type u₂
inst✝¹ : Bifunctor F
inst✝ : LawfulBifunctor F
α₀ α₁ : Type u₀
β₀ β₁ : Type u₁
f : α₀ → α₁
f' : β₀ → β₁
x : F α₀ β₀
⊢ fst f (snd f' x) = bimap f f' x