tasksource/leandojo huggingface dataset:
Theorem: mul_eq_mul_iff_eq_and_eq_of_pos'
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: rcases hac.eq_or_lt with (rfl | hac)
state_before: α : Type u_1
a b c d : α
inst✝⁵ : MulZeroClass α
inst✝⁴ : PartialOrder α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : PosMulMonoRev α
inst✝ : MulPosMonoRev α
hac : a ≤ b
hbd : c ≤ d
b0 : 0 < b
c0 : 0 < c
h : a * c = b * d
⊢ a = b ∧ c = d

tactic: rcases eq_or_lt_of_le hbd with (rfl | hbd)
state_before: case inr
α : Type u_1
a b c d : α
inst✝⁵ : MulZeroClass α
inst✝⁴ : PartialOrder α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : PosMulMonoRev α
inst✝ : MulPosMonoRev α
hac✝ : a ≤ b
hbd : c ≤ d
b0 : 0 < b
c0 : 0 < c
h : a * c = b * d
hac : a < b
⊢ a = b ∧ c = d

tactic: exact ((mul_lt_mul_of_lt_of_lt' hac hbd b0 c0).ne h).elim
state_before: case inr.inr
α : Type u_1
a b c d : α
inst✝⁵ : MulZeroClass α
inst✝⁴ : PartialOrder α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : PosMulMonoRev α
inst✝ : MulPosMonoRev α
hac✝ : a ≤ b
hbd✝ : c ≤ d
b0 : 0 < b
c0 : 0 < c
h : a * c = b * d
hac : a < b
hbd : c < d
⊢ a = b ∧ c = d

tactic: exact ⟨rfl, (mul_left_cancel_iff_of_pos b0).mp h⟩
state_before: case inl
α : Type u_1
a c d : α
inst✝⁵ : MulZeroClass α
inst✝⁴ : PartialOrder α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : PosMulMonoRev α
inst✝ : MulPosMonoRev α
hbd : c ≤ d
c0 : 0 < c
hac : a ≤ a
b0 : 0 < a
h : a * c = a * d
⊢ a = a ∧ c = d

tactic: exact ⟨(mul_right_cancel_iff_of_pos c0).mp h, rfl⟩
state_before: case inr.inl
α : Type u_1
a b c : α
inst✝⁵ : MulZeroClass α
inst✝⁴ : PartialOrder α
inst✝³ : PosMulStrictMono α
inst✝² : MulPosStrictMono α
inst✝¹ : PosMulMonoRev α
inst✝ : MulPosMonoRev α
hac✝ : a ≤ b
b0 : 0 < b
c0 : 0 < c
hac : a < b
hbd : c ≤ c
h : a * c = b * c
⊢ a = b ∧ c = c
Theorem: Filter.sup_liminf
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [liminf_eq_iSup_iInf]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.166973
ι : Type ?u.166976
inst✝ : CompleteDistribLattice α
f : Filter β
p q : β → Prop
u : β → α
a : α
⊢ a ⊔ liminf u f = liminf (fun x => a ⊔ u x) f

tactic: rw [sup_comm, biSup_sup (⟨univ, univ_mem⟩ : ∃ i : Set β, i ∈ f)]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.166973
ι : Type ?u.166976
inst✝ : CompleteDistribLattice α
f : Filter β
p q : β → Prop
u : β → α
a : α
⊢ (a ⊔ ⨆ (s : Set β) (_ : s ∈ f), ⨅ (a : β) (_ : a ∈ s), u a) =
    ⨆ (s : Set β) (_ : s ∈ f), ⨅ (a_1 : β) (_ : a_1 ∈ s), a ⊔ u a_1

tactic: simp_rw [iInf₂_sup_eq, sup_comm (a := a)]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.166973
ι : Type ?u.166976
inst✝ : CompleteDistribLattice α
f : Filter β
p q : β → Prop
u : β → α
a : α
⊢ (⨆ (i : Set β) (_ : i ∈ f), (⨅ (a : β) (_ : a ∈ i), u a) ⊔ a) =
    ⨆ (s : Set β) (_ : s ∈ f), ⨅ (a_1 : β) (_ : a_1 ∈ s), a ⊔ u a_1
Theorem: ENNReal.orderIsoRpow_symm_apply
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simp only [orderIsoRpow, one_div_one_div]
state_before: y : ℝ
hy : 0 < y
⊢ OrderIso.symm (orderIsoRpow y hy) = orderIsoRpow (1 / y) (_ : 0 < 1 / y)

tactic: rfl
state_before: y : ℝ
hy : 0 < y
⊢ OrderIso.symm
      (StrictMono.orderIsoOfRightInverse (fun x => x ^ y) (_ : StrictMono fun x => x ^ y) (fun x => x ^ (1 / y))
        (_ : ∀ (x : ℝ≥0∞), (fun x => x ^ y) ((fun x => x ^ (1 / y)) x) = x)) =
    StrictMono.orderIsoOfRightInverse (fun x => x ^ (1 / y)) (_ : StrictMono fun x => x ^ (1 / y)) (fun x => x ^ y)
      (_ : Function.RightInverse (fun x => x ^ y) fun x => x ^ (1 / y))
Theorem: orthogonalProjection_bot
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: ext
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.555301
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
⊢ orthogonalProjection ⊥ = 0
Theorem: SemiconjBy.neg_right
File: Mathlib/Algebra/Ring/Semiconj.lean

tactic: simp only [SemiconjBy, h.eq, neg_mul, mul_neg]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Mul R
inst✝ : HasDistribNeg R
a x y : R
h : SemiconjBy a x y
⊢ SemiconjBy a (-x) (-y)
Theorem: zero_lt_one_add_norm_sq'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: positivity
state_before: 𝓕 : Type ?u.74877
𝕜 : Type ?u.74880
α : Type ?u.74883
ι : Type ?u.74886
κ : Type ?u.74889
E : Type u_1
F : Type ?u.74895
G : Type ?u.74898
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
x : E
⊢ 0 < 1 + ‖x‖ ^ 2
Theorem: GroupWithZero.eq_zero_or_unit
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: by_cases h : a = 0
state_before: α : Type ?u.16951
M₀ : Type ?u.16954
G₀ : Type u_1
M₀' : Type ?u.16960
G₀' : Type ?u.16963
F : Type ?u.16966
F' : Type ?u.16969
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a✝ b a : G₀
⊢ a = 0 ∨ ∃ u, a = ↑u

tactic: left
state_before: case pos
α : Type ?u.16951
M₀ : Type ?u.16954
G₀ : Type u_1
M₀' : Type ?u.16960
G₀' : Type ?u.16963
F : Type ?u.16966
F' : Type ?u.16969
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a✝ b a : G₀
h : a = 0
⊢ a = 0 ∨ ∃ u, a = ↑u

tactic: exact h
state_before: case pos.h
α : Type ?u.16951
M₀ : Type ?u.16954
G₀ : Type u_1
M₀' : Type ?u.16960
G₀' : Type ?u.16963
F : Type ?u.16966
F' : Type ?u.16969
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a✝ b a : G₀
h : a = 0
⊢ a = 0

tactic: right
state_before: case neg
α : Type ?u.16951
M₀ : Type ?u.16954
G₀ : Type u_1
M₀' : Type ?u.16960
G₀' : Type ?u.16963
F : Type ?u.16966
F' : Type ?u.16969
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a✝ b a : G₀
h : ¬a = 0
⊢ a = 0 ∨ ∃ u, a = ↑u

tactic: simpa only [eq_comm] using Units.exists_iff_ne_zero.mpr h
state_before: case neg.h
α : Type ?u.16951
M₀ : Type ?u.16954
G₀ : Type u_1
M₀' : Type ?u.16960
G₀' : Type ?u.16963
F : Type ?u.16966
F' : Type ?u.16969
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a✝ b a : G₀
h : ¬a = 0
⊢ ∃ u, a = ↑u
Theorem: MvPolynomial.mem_supported_vars
File: Mathlib/Data/MvPolynomial/Supported.lean

tactic: rw [mem_supported]
state_before: σ : Type u_1
τ : Type ?u.124945
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝ : CommSemiring R
p✝ q : MvPolynomial σ R
s t : Set σ
p : MvPolynomial σ R
⊢ p ∈ supported R ↑(vars p)
Theorem: Quaternion.normSq_eq_zero
File: Mathlib/Algebra/Quaternion.lean

tactic: refine' ⟨fun h => _, fun h => h.symm ▸ normSq.map_zero⟩
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
⊢ ↑normSq a = 0 ↔ a = 0

tactic: rw [normSq_def', add_eq_zero_iff', add_eq_zero_iff', add_eq_zero_iff'] at h
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : ↑normSq a = 0
⊢ a = 0

tactic: exact ext a 0 (pow_eq_zero h.1.1.1) (pow_eq_zero h.1.1.2) (pow_eq_zero h.1.2) (pow_eq_zero h.2)
state_before: R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : ((a.re ^ 2 = 0 ∧ a.imI ^ 2 = 0) ∧ a.imJ ^ 2 = 0) ∧ a.imK ^ 2 = 0
⊢ a = 0

case ha
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : (a.re ^ 2 + a.imI ^ 2 = 0 ∧ a.imJ ^ 2 = 0) ∧ a.imK ^ 2 = 0
⊢ 0 ≤ a.re ^ 2

case hb
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : (a.re ^ 2 + a.imI ^ 2 = 0 ∧ a.imJ ^ 2 = 0) ∧ a.imK ^ 2 = 0
⊢ 0 ≤ a.imI ^ 2

case ha
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2 = 0 ∧ a.imK ^ 2 = 0
⊢ 0 ≤ a.re ^ 2 + a.imI ^ 2

case hb
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2 = 0 ∧ a.imK ^ 2 = 0
⊢ 0 ≤ a.imJ ^ 2

case ha
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2 + a.imK ^ 2 = 0
⊢ 0 ≤ a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2

case hb
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2 + a.imK ^ 2 = 0
⊢ 0 ≤ a.imK ^ 2

tactic: all_goals apply_rules [sq_nonneg, add_nonneg]
state_before: case ha
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : (a.re ^ 2 + a.imI ^ 2 = 0 ∧ a.imJ ^ 2 = 0) ∧ a.imK ^ 2 = 0
⊢ 0 ≤ a.re ^ 2

case hb
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : (a.re ^ 2 + a.imI ^ 2 = 0 ∧ a.imJ ^ 2 = 0) ∧ a.imK ^ 2 = 0
⊢ 0 ≤ a.imI ^ 2

case ha
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2 = 0 ∧ a.imK ^ 2 = 0
⊢ 0 ≤ a.re ^ 2 + a.imI ^ 2

case hb
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2 = 0 ∧ a.imK ^ 2 = 0
⊢ 0 ≤ a.imJ ^ 2

case ha
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2 + a.imK ^ 2 = 0
⊢ 0 ≤ a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2

case hb
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2 + a.imK ^ 2 = 0
⊢ 0 ≤ a.imK ^ 2

tactic: apply_rules [sq_nonneg, add_nonneg]
state_before: case hb
R : Type u_1
inst✝ : LinearOrderedCommRing R
a : ℍ[R]
h : a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2 + a.imK ^ 2 = 0
⊢ 0 ≤ a.imK ^ 2
Theorem: Polynomial.IsSplittingField.mul
File: Mathlib/FieldTheory/SplittingField/IsSplittingField.lean

tactic: rw [Polynomial.map_mul,
  roots_mul (mul_ne_zero (map_ne_zero hf : f.map (algebraMap F L) ≠ 0) (map_ne_zero hg)),
  Multiset.toFinset_add, Finset.coe_union, Algebra.adjoin_union_eq_adjoin_adjoin,
  IsScalarTower.algebraMap_eq F K L, ← map_map,
  roots_map (algebraMap K L) ((splits_id_iff_splits <| algebraMap F K).2 <| splits K f),
  Multiset.toFinset_map, Finset.coe_image, Algebra.adjoin_algebraMap, adjoin_roots,
  Algebra.map_top, IsScalarTower.adjoin_range_toAlgHom, ← map_map, adjoin_roots,
  Subalgebra.restrictScalars_top]
state_before: F : Type u
K : Type v
L : Type w
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : Field F
inst✝⁵ : Algebra K L
inst✝⁴ : Algebra F K
inst✝³ : Algebra F L
inst✝² : IsScalarTower F K L
f g : F[X]
hf : f ≠ 0
hg : g ≠ 0
inst✝¹ : IsSplittingField F K f
inst✝ : IsSplittingField K L (Polynomial.map (algebraMap F K) g)
⊢ Algebra.adjoin F ↑(Multiset.toFinset (roots (Polynomial.map (algebraMap F L) (f * g)))) = ⊤
Theorem: oneOneReducible_refl
File: Mathlib/Computability/Reduce.lean

tactic: simp
state_before: α : Type u_1
inst✝ : Primcodable α
p : α → Prop
⊢ ∀ (a : α), p a ↔ p (id a)
Theorem: Set.range_comp_subset_range
File: Mathlib/Data/Set/Image.lean

tactic: rw [range_comp]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
ι : Sort ?u.71922
ι' : Sort ?u.71925
f✝ : ι → α
s t : Set α
f : α → β
g : β → γ
⊢ range (g ∘ f) ⊆ range g

tactic: apply image_subset_range
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
ι : Sort ?u.71922
ι' : Sort ?u.71925
f✝ : ι → α
s t : Set α
f : α → β
g : β → γ
⊢ g '' range f ⊆ range g
Theorem: QuotientAddGroup.norm_lift_apply_le
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: cases (norm_nonneg f).eq_or_gt with
| inl h =>
  rcases mk_surjective x with ⟨x, rfl⟩
  simpa [h] using le_opNorm f x
| inr h =>
  rw [← not_lt, ← _root_.lt_div_iff' h, norm_lt_iff]
  rintro ⟨x, rfl, hx⟩
  exact ((lt_div_iff' h).1 hx).not_le (le_opNorm f x)
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
f : NormedAddGroupHom M N
hf : ∀ (x : M), x ∈ S → ↑f x = 0
x : M ⧸ S
⊢ ‖↑(lift S (toAddMonoidHom f) hf) x‖ ≤ ‖f‖ * ‖x‖

tactic: rcases mk_surjective x with ⟨x, rfl⟩
state_before: case inl
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
f : NormedAddGroupHom M N
hf : ∀ (x : M), x ∈ S → ↑f x = 0
x : M ⧸ S
h : ‖f‖ = 0
⊢ ‖↑(lift S (toAddMonoidHom f) hf) x‖ ≤ ‖f‖ * ‖x‖

tactic: simpa [h] using le_opNorm f x
state_before: case inl.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
f : NormedAddGroupHom M N
hf : ∀ (x : M), x ∈ S → ↑f x = 0
h : ‖f‖ = 0
x : M
⊢ ‖↑(lift S (toAddMonoidHom f) hf) ↑x‖ ≤ ‖f‖ * ‖↑x‖

tactic: rw [← not_lt, ← _root_.lt_div_iff' h, norm_lt_iff]
state_before: case inr
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
f : NormedAddGroupHom M N
hf : ∀ (x : M), x ∈ S → ↑f x = 0
x : M ⧸ S
h : 0 < ‖f‖
⊢ ‖↑(lift S (toAddMonoidHom f) hf) x‖ ≤ ‖f‖ * ‖x‖

tactic: rintro ⟨x, rfl, hx⟩
state_before: case inr
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
f : NormedAddGroupHom M N
hf : ∀ (x : M), x ∈ S → ↑f x = 0
x : M ⧸ S
h : 0 < ‖f‖
⊢ ¬∃ m, ↑m = x ∧ ‖m‖ < ‖↑(lift S (toAddMonoidHom f) hf) x‖ / ‖f‖

tactic: exact ((lt_div_iff' h).1 hx).not_le (le_opNorm f x)
state_before: case inr.intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
f : NormedAddGroupHom M N
hf : ∀ (x : M), x ∈ S → ↑f x = 0
h : 0 < ‖f‖
x : M
hx : ‖x‖ < ‖↑(lift S (toAddMonoidHom f) hf) ↑x‖ / ‖f‖
⊢ False
Theorem: EventuallyLE.countable_bUnion
File: Mathlib/Order/Filter/CountableInter.lean

tactic: simp only [biUnion_eq_iUnion]
state_before: ι✝ : Sort ?u.3007
α : Type u_2
β : Type ?u.3013
l : Filter α
inst✝ : CountableInterFilter l
ι : Type u_1
S : Set ι
hS : Set.Countable S
s t : (i : ι) → i ∈ S → Set α
h : ∀ (i : ι) (hi : i ∈ S), s i hi ≤ᶠ[l] t i hi
⊢ (⋃ (i : ι) (h : i ∈ S), s i h) ≤ᶠ[l] ⋃ (i : ι) (h : i ∈ S), t i h

tactic: haveI := hS.toEncodable
state_before: ι✝ : Sort ?u.3007
α : Type u_2
β : Type ?u.3013
l : Filter α
inst✝ : CountableInterFilter l
ι : Type u_1
S : Set ι
hS : Set.Countable S
s t : (i : ι) → i ∈ S → Set α
h : ∀ (i : ι) (hi : i ∈ S), s i hi ≤ᶠ[l] t i hi
⊢ (⋃ (x : ↑S), s ↑x (_ : ↑x ∈ S)) ≤ᶠ[l] ⋃ (x : ↑S), t ↑x (_ : ↑x ∈ S)

tactic: exact EventuallyLE.countable_iUnion fun i => h i i.2
state_before: ι✝ : Sort ?u.3007
α : Type u_2
β : Type ?u.3013
l : Filter α
inst✝ : CountableInterFilter l
ι : Type u_1
S : Set ι
hS : Set.Countable S
s t : (i : ι) → i ∈ S → Set α
h : ∀ (i : ι) (hi : i ∈ S), s i hi ≤ᶠ[l] t i hi
this : Encodable ↑S
⊢ (⋃ (x : ↑S), s ↑x (_ : ↑x ∈ S)) ≤ᶠ[l] ⋃ (x : ↑S), t ↑x (_ : ↑x ∈ S)
Theorem: CategoryTheory.CommSq.right_adjoint
File: Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean

tactic: simp only [Adjunction.homEquiv_unit, assoc, ← F.map_comp, sq.w]
state_before: C : Type u_1
D : Type u_4
inst✝¹ : Category C
inst✝ : Category D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : G.obj A ⟶ X
v : G.obj B ⟶ Y
sq : CommSq u (G.map i) p v
adj : G ⊣ F
⊢ ↑(Adjunction.homEquiv adj A X) u ≫ F.map p = i ≫ ↑(Adjunction.homEquiv adj B Y) v

tactic: rw [F.map_comp, Adjunction.unit_naturality_assoc]
state_before: C : Type u_1
D : Type u_4
inst✝¹ : Category C
inst✝ : Category D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : G.obj A ⟶ X
v : G.obj B ⟶ Y
sq : CommSq u (G.map i) p v
adj : G ⊣ F
⊢ adj.unit.app A ≫ F.map (G.map i ≫ v) = i ≫ adj.unit.app B ≫ F.map v
Theorem: Finset.image₂_union_inter_subset_union
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_2
α' : Type ?u.102139
β : Type u_3
β' : Type ?u.102145
γ : Type u_1
γ' : Type ?u.102151
δ : Type ?u.102154
δ' : Type ?u.102157
ε : Type ?u.102160
ε' : Type ?u.102163
ζ : Type ?u.102166
ζ' : Type ?u.102169
ν : Type ?u.102172
inst✝⁹ : DecidableEq α'
inst✝⁸ : DecidableEq β'
inst✝⁷ : DecidableEq γ
inst✝⁶ : DecidableEq γ'
inst✝⁵ : DecidableEq δ
inst✝⁴ : DecidableEq δ'
inst✝³ : DecidableEq ε
inst✝² : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ↑(image₂ f (s ∪ s') (t ∩ t')) ⊆ ↑(image₂ f s t ∪ image₂ f s' t')

tactic: exact Set.image2_union_inter_subset_union
state_before: α : Type u_2
α' : Type ?u.102139
β : Type u_3
β' : Type ?u.102145
γ : Type u_1
γ' : Type ?u.102151
δ : Type ?u.102154
δ' : Type ?u.102157
ε : Type ?u.102160
ε' : Type ?u.102163
ζ : Type ?u.102166
ζ' : Type ?u.102169
ν : Type ?u.102172
inst✝⁹ : DecidableEq α'
inst✝⁸ : DecidableEq β'
inst✝⁷ : DecidableEq γ
inst✝⁶ : DecidableEq γ'
inst✝⁵ : DecidableEq δ
inst✝⁴ : DecidableEq δ'
inst✝³ : DecidableEq ε
inst✝² : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ image2 f (↑s ∪ ↑s') (↑t ∩ ↑t') ⊆ image2 f ↑s ↑t ∪ image2 f ↑s' ↑t'
Theorem: HahnSeries.mul_coeff_right'
File: Mathlib/RingTheory/HahnSeries.lean

tactic: rw [mul_coeff]
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
a : Γ
s : Set Γ
hs : Set.IsPwo s
hys : support y ⊆ s
⊢ coeff (x * y) a = ∑ ij in addAntidiagonal (_ : Set.IsPwo (support x)) hs a, coeff x ij.fst * coeff y ij.snd

tactic: apply sum_subset_zero_on_sdiff (addAntidiagonal_mono_right hys) _ fun _ _ => rfl
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
a : Γ
s : Set Γ
hs : Set.IsPwo s
hys : support y ⊆ s
⊢ ∑ ij in addAntidiagonal (_ : Set.IsPwo (support x)) (_ : Set.IsPwo (support y)) a, coeff x ij.fst * coeff y ij.snd =
    ∑ ij in addAntidiagonal (_ : Set.IsPwo (support x)) hs a, coeff x ij.fst * coeff y ij.snd

tactic: intro b hb
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
a : Γ
s : Set Γ
hs : Set.IsPwo s
hys : support y ⊆ s
⊢ ∀ (x_1 : Γ × Γ),
    x_1 ∈
        addAntidiagonal (_ : Set.IsPwo (support x)) hs a \
          addAntidiagonal (_ : Set.IsPwo (support x)) (_ : Set.IsPwo (support y)) a →
      coeff x x_1.fst * coeff y x_1.snd = 0

tactic: simp only [not_and, mem_sdiff, mem_addAntidiagonal, mem_support, not_imp_not] at hb
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
a : Γ
s : Set Γ
hs : Set.IsPwo s
hys : support y ⊆ s
b : Γ × Γ
hb :
  b ∈
    addAntidiagonal (_ : Set.IsPwo (support x)) hs a \
      addAntidiagonal (_ : Set.IsPwo (support x)) (_ : Set.IsPwo (support y)) a
⊢ coeff x b.fst * coeff y b.snd = 0

tactic: rw [hb.2 hb.1.1 hb.1.2.2, MulZeroClass.mul_zero]
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
a : Γ
s : Set Γ
hs : Set.IsPwo s
hys : support y ⊆ s
b : Γ × Γ
hb : (coeff x b.fst ≠ 0 ∧ b.snd ∈ s ∧ b.fst + b.snd = a) ∧ (coeff x b.fst ≠ 0 → b.fst + b.snd = a → coeff y b.snd = 0)
⊢ coeff x b.fst * coeff y b.snd = 0
Theorem: CategoryTheory.MonoidalCategory.hom_inv_id_tensor
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← tensor_comp, f.hom_inv_id, id_tensor_comp]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ (f.hom ⊗ g) ≫ (f.inv ⊗ h) = (𝟙 V ⊗ g) ≫ (𝟙 V ⊗ h)
Theorem: IsUnifLocDoublingMeasure.eventually_measure_le_scaling_constant_mul
File: Mathlib/MeasureTheory/Measure/Doubling.lean

tactic: filter_upwards [Classical.choose_spec
    (exists_eventually_forall_measure_closedBall_le_mul μ K)]with r hr x
state_before: α : Type u_1
inst✝² : MetricSpace α
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
inst✝ : IsUnifLocDoublingMeasure μ
K : ℝ
⊢ ∀ᶠ (r : ℝ) in 𝓝[Ioi 0] 0, ∀ (x : α), ↑↑μ (closedBall x (K * r)) ≤ ↑(scalingConstantOf μ K) * ↑↑μ (closedBall x r)

tactic: exact (hr x K le_rfl).trans (mul_le_mul_right' (ENNReal.coe_le_coe.2 (le_max_left _ _)) _)
state_before: case h
α : Type u_1
inst✝² : MetricSpace α
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
inst✝ : IsUnifLocDoublingMeasure μ
K r : ℝ
hr :
  ∀ (x : α) (t : ℝ),
    t ≤ K →
      ↑↑μ (closedBall x (t * r)) ≤
        ↑(Classical.choose
              (_ :
                ∃ C,
                  ∀ᶠ (ε : ℝ) in 𝓝[Ioi 0] 0,
                    ∀ (x : α) (t : ℝ), t ≤ K → ↑↑μ (closedBall x (t * ε)) ≤ ↑C * ↑↑μ (closedBall x ε))) *
          ↑↑μ (closedBall x r)
x : α
⊢ ↑↑μ (closedBall x (K * r)) ≤ ↑(scalingConstantOf μ K) * ↑↑μ (closedBall x r)
Theorem: CategoryTheory.Grothendieck.ext
File: Mathlib/CategoryTheory/Grothendieck.lean

tactic: rw [w_base]
state_before: C : Type ?u.2075
D : Type ?u.2078
inst✝¹ : Category C
inst✝ : Category D
F : C ⥤ Cat
X Y : Grothendieck F
f g : Hom X Y
w_base : f.base = g.base
⊢ (F.map g.base).obj X.fiber = (F.map f.base).obj X.fiber

tactic: cases f
state_before: C : Type u_1
D : Type ?u.2078
inst✝¹ : Category C
inst✝ : Category D
F : C ⥤ Cat
X Y : Grothendieck F
f g : Hom X Y
w_base : f.base = g.base
w_fiber : eqToHom (_ : (F.map g.base).obj X.fiber = (F.map f.base).obj X.fiber) ≫ f.fiber = g.fiber
⊢ f = g

tactic: cases g
state_before: case mk
C : Type u_1
D : Type ?u.2078
inst✝¹ : Category C
inst✝ : Category D
F : C ⥤ Cat
X Y : Grothendieck F
g : Hom X Y
base✝ : X.base ⟶ Y.base
fiber✝ : (F.map base✝).obj X.fiber ⟶ Y.fiber
w_base : { base := base✝, fiber := fiber✝ }.base = g.base
w_fiber :
  eqToHom (_ : (F.map g.base).obj X.fiber = (F.map { base := base✝, fiber := fiber✝ }.base).obj X.fiber) ≫
      { base := base✝, fiber := fiber✝ }.fiber =
    g.fiber
⊢ { base := base✝, fiber := fiber✝ } = g

tactic: congr
state_before: case mk.mk
C : Type u_1
D : Type ?u.2078
inst✝¹ : Category C
inst✝ : Category D
F : C ⥤ Cat
X Y : Grothendieck F
base✝¹ : X.base ⟶ Y.base
fiber✝¹ : (F.map base✝¹).obj X.fiber ⟶ Y.fiber
base✝ : X.base ⟶ Y.base
fiber✝ : (F.map base✝).obj X.fiber ⟶ Y.fiber
w_base : { base := base✝¹, fiber := fiber✝¹ }.base = { base := base✝, fiber := fiber✝ }.base
w_fiber :
  eqToHom
        (_ :
          (F.map { base := base✝, fiber := fiber✝ }.base).obj X.fiber =
            (F.map { base := base✝¹, fiber := fiber✝¹ }.base).obj X.fiber) ≫
      { base := base✝¹, fiber := fiber✝¹ }.fiber =
    { base := base✝, fiber := fiber✝ }.fiber
⊢ { base := base✝¹, fiber := fiber✝¹ } = { base := base✝, fiber := fiber✝ }

tactic: dsimp at w_base
state_before: case mk.mk.h.e_7
C : Type u_1
D : Type ?u.2078
inst✝¹ : Category C
inst✝ : Category D
F : C ⥤ Cat
X Y : Grothendieck F
base✝¹ : X.base ⟶ Y.base
fiber✝¹ : (F.map base✝¹).obj X.fiber ⟶ Y.fiber
base✝ : X.base ⟶ Y.base
fiber✝ : (F.map base✝).obj X.fiber ⟶ Y.fiber
w_base : { base := base✝¹, fiber := fiber✝¹ }.base = { base := base✝, fiber := fiber✝ }.base
w_fiber :
  eqToHom
        (_ :
          (F.map { base := base✝, fiber := fiber✝ }.base).obj X.fiber =
            (F.map { base := base✝¹, fiber := fiber✝¹ }.base).obj X.fiber) ≫
      { base := base✝¹, fiber := fiber✝¹ }.fiber =
    { base := base✝, fiber := fiber✝ }.fiber
⊢ HEq fiber✝¹ fiber✝

tactic: aesop_cat
state_before: case mk.mk.h.e_7
C : Type u_1
D : Type ?u.2078
inst✝¹ : Category C
inst✝ : Category D
F : C ⥤ Cat
X Y : Grothendieck F
base✝¹ : X.base ⟶ Y.base
fiber✝¹ : (F.map base✝¹).obj X.fiber ⟶ Y.fiber
base✝ : X.base ⟶ Y.base
fiber✝ : (F.map base✝).obj X.fiber ⟶ Y.fiber
w_base : base✝¹ = base✝
w_fiber :
  eqToHom
        (_ :
          (F.map { base := base✝, fiber := fiber✝ }.base).obj X.fiber =
            (F.map { base := base✝¹, fiber := fiber✝¹ }.base).obj X.fiber) ≫
      { base := base✝¹, fiber := fiber✝¹ }.fiber =
    { base := base✝, fiber := fiber✝ }.fiber
⊢ HEq fiber✝¹ fiber✝