tasksource/leandojo huggingface dataset:
Theorem: AdjoinRoot.liftHom_eq_algHom
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: suffices ϕ.equalizer (liftHom f (ϕ (root f)) (aeval_algHom_eq_zero f ϕ)) = ⊤ by
  exact (AlgHom.ext fun x => (SetLike.ext_iff.mp this x).mpr Algebra.mem_top).symm
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
f✝ : R[X]
inst✝¹ : CommRing S
i : R →+* S
a : S
h : eval₂ i a f✝ = 0
inst✝ : Algebra R S
f : R[X]
ϕ : AdjoinRoot f →ₐ[R] S
⊢ liftHom f (↑ϕ (root f)) (_ : ↑(aeval (↑ϕ (root f))) f = 0) = ϕ

tactic: rw [eq_top_iff, ← adjoinRoot_eq_top, Algebra.adjoin_le_iff, Set.singleton_subset_iff]
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
f✝ : R[X]
inst✝¹ : CommRing S
i : R →+* S
a : S
h : eval₂ i a f✝ = 0
inst✝ : Algebra R S
f : R[X]
ϕ : AdjoinRoot f →ₐ[R] S
⊢ AlgHom.equalizer ϕ (liftHom f (↑ϕ (root f)) (_ : ↑(aeval (↑ϕ (root f))) f = 0)) = ⊤

tactic: exact (@lift_root _ _ _ _ _ _ _ (aeval_algHom_eq_zero f ϕ)).symm
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
f✝ : R[X]
inst✝¹ : CommRing S
i : R →+* S
a : S
h : eval₂ i a f✝ = 0
inst✝ : Algebra R S
f : R[X]
ϕ : AdjoinRoot f →ₐ[R] S
⊢ root f ∈ ↑(AlgHom.equalizer ϕ (liftHom f (↑ϕ (root f)) (_ : ↑(aeval (↑ϕ (root f))) f = 0)))

tactic: exact (AlgHom.ext fun x => (SetLike.ext_iff.mp this x).mpr Algebra.mem_top).symm
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
f✝ : R[X]
inst✝¹ : CommRing S
i : R →+* S
a : S
h : eval₂ i a f✝ = 0
inst✝ : Algebra R S
f : R[X]
ϕ : AdjoinRoot f →ₐ[R] S
this : AlgHom.equalizer ϕ (liftHom f (↑ϕ (root f)) (_ : ↑(aeval (↑ϕ (root f))) f = 0)) = ⊤
⊢ liftHom f (↑ϕ (root f)) (_ : ↑(aeval (↑ϕ (root f))) f = 0) = ϕ
Theorem: circleIntegral.integral_smul
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp only [circleIntegral, ← smul_comm a (_ : ℂ) (_ : E), intervalIntegral.integral_smul]
state_before: E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℂ E
inst✝³ : CompleteSpace E
𝕜 : Type u_1
inst✝² : IsROrC 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : SMulCommClass 𝕜 ℂ E
a : 𝕜
f : ℂ → E
c : ℂ
R : ℝ
⊢ (∮ (z : ℂ) in C(c, R), a • f z) = a • ∮ (z : ℂ) in C(c, R), f z
Theorem: CategoryTheory.comp_eq_zero_of_image_eq_kernel
File: Mathlib/Algebra/Homology/Exact.lean

tactic: suffices Subobject.arrow (imageSubobject f) ≫ g = 0 by
  rw [← imageSubobject_arrow_comp f, Category.assoc, this, comp_zero]
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
⊢ f ≫ g = 0

tactic: rw [p, kernelSubobject_arrow_comp]
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
⊢ Subobject.arrow (imageSubobject f) ≫ g = 0

tactic: rw [← imageSubobject_arrow_comp f, Category.assoc, this, comp_zero]
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
this : Subobject.arrow (imageSubobject f) ≫ g = 0
⊢ f ≫ g = 0
Theorem: Polynomial.support_C_mul_X
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [C_mul_X_eq_monomial, support_monomial 1 h]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
c : R
h : c ≠ 0
⊢ support (↑C c * X) = {1}
Theorem: Complex.I_pow_bit1
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [pow_bit1', Complex.I_mul_I]
state_before: n : ℕ
⊢ I ^ bit1 n = (-1) ^ n * I
Theorem: MeasureTheory.L1.SimpleFunc.setToL1S_neg
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: simp_rw [setToL1S]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.671027
G : Type ?u.671030
𝕜 : Type ?u.671033
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0
h_add : FinMeasAdditive μ T
f : { x // x ∈ simpleFunc E 1 μ }
⊢ setToL1S T (-f) = -setToL1S T f

tactic: have : simpleFunc.toSimpleFunc (-f) =ᵐ[μ] ⇑(-simpleFunc.toSimpleFunc f) :=
  neg_toSimpleFunc f
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.671027
G : Type ?u.671030
𝕜 : Type ?u.671033
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0
h_add : FinMeasAdditive μ T
f : { x // x ∈ simpleFunc E 1 μ }
⊢ SimpleFunc.setToSimpleFunc T (toSimpleFunc (-f)) = -SimpleFunc.setToSimpleFunc T (toSimpleFunc f)

tactic: rw [SimpleFunc.setToSimpleFunc_congr T h_zero h_add (SimpleFunc.integrable _) this]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.671027
G : Type ?u.671030
𝕜 : Type ?u.671033
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0
h_add : FinMeasAdditive μ T
f : { x // x ∈ simpleFunc E 1 μ }
this : ↑(toSimpleFunc (-f)) =ᵐ[μ] ↑(-toSimpleFunc f)
⊢ SimpleFunc.setToSimpleFunc T (toSimpleFunc (-f)) = -SimpleFunc.setToSimpleFunc T (toSimpleFunc f)

tactic: exact SimpleFunc.setToSimpleFunc_neg T h_add (SimpleFunc.integrable f)
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.671027
G : Type ?u.671030
𝕜 : Type ?u.671033
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0
h_add : FinMeasAdditive μ T
f : { x // x ∈ simpleFunc E 1 μ }
this : ↑(toSimpleFunc (-f)) =ᵐ[μ] ↑(-toSimpleFunc f)
⊢ SimpleFunc.setToSimpleFunc T (-toSimpleFunc f) = -SimpleFunc.setToSimpleFunc T (toSimpleFunc f)
Theorem: Ordinal.principal_one_iff
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: refine' ⟨fun h => _, fun h a b ha hb => _⟩
state_before: op : Ordinal → Ordinal → Ordinal
⊢ Principal op 1 ↔ op 0 0 = 0

tactic: rw [← lt_one_iff_zero]
state_before: case refine'_1
op : Ordinal → Ordinal → Ordinal
h : Principal op 1
⊢ op 0 0 = 0

tactic: exact h zero_lt_one zero_lt_one
state_before: case refine'_1
op : Ordinal → Ordinal → Ordinal
h : Principal op 1
⊢ op 0 0 < 1

tactic: rwa [lt_one_iff_zero, ha, hb] at *
state_before: case refine'_2
op : Ordinal → Ordinal → Ordinal
h : op 0 0 = 0
a b : Ordinal
ha : a < 1
hb : b < 1
⊢ op a b < 1
Theorem: Real.exp_bound
File: Mathlib/Data/Complex/Exponential.lean

tactic: have hxc : Complex.abs x ≤ 1 := by exact_mod_cast hx
state_before: x : ℝ
hx : abs' x ≤ 1
n : ℕ
hn : 0 < n
⊢ abs' (exp x - ∑ m in range n, x ^ m / ↑(Nat.factorial m)) ≤ abs' x ^ n * (↑(Nat.succ n) / (↑(Nat.factorial n) * ↑n))

tactic: convert exp_bound hxc hn using 2 <;>
simp only [← abs_ofReal, ← ofReal_sub, ← ofReal_exp, ← ofReal_sum, ← ofReal_pow,
  ← ofReal_div, ← ofReal_nat_cast]
state_before: x : ℝ
hx : abs' x ≤ 1
n : ℕ
hn : 0 < n
hxc : ↑Complex.abs ↑x ≤ 1
⊢ abs' (exp x - ∑ m in range n, x ^ m / ↑(Nat.factorial m)) ≤ abs' x ^ n * (↑(Nat.succ n) / (↑(Nat.factorial n) * ↑n))

tactic: exact_mod_cast hx
state_before: x : ℝ
hx : abs' x ≤ 1
n : ℕ
hn : 0 < n
⊢ ↑Complex.abs ↑x ≤ 1
Theorem: Matrix.cramer_submatrix_equiv
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: ext i
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A✝ : Matrix n n α
b✝ : n → α
A : Matrix m m α
e : n ≃ m
b : n → α
⊢ ↑(cramer (submatrix A ↑e ↑e)) b = ↑(cramer A) (b ∘ ↑e.symm) ∘ ↑e

tactic: simp_rw [Function.comp_apply, cramer_apply, updateColumn_submatrix_equiv,
  det_submatrix_equiv_self e, Function.comp]
state_before: case h
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A✝ : Matrix n n α
b✝ : n → α
A : Matrix m m α
e : n ≃ m
b : n → α
i : n
⊢ ↑(cramer (submatrix A ↑e ↑e)) b i = (↑(cramer A) (b ∘ ↑e.symm) ∘ ↑e) i
Theorem: irrational_div_rat_iff
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [div_eq_mul_inv, ← cast_inv, irrational_mul_rat_iff, Ne.def, inv_eq_zero]
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (x / ↑q) ↔ q ≠ 0 ∧ Irrational x
Theorem: Subsemigroup.closure_induction'
File: Mathlib/GroupTheory/Subsemigroup/Basic.lean

tactic: refine' Exists.elim _ fun (hx : x ∈ closure s) (hc : p x hx) => hc
state_before: M : Type u_1
N : Type ?u.16694
A : Type ?u.16697
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
s : Set M
p : (x : M) → x ∈ closure s → Prop
Hs : ∀ (x : M) (h : x ∈ s), p x (_ : x ∈ ↑(closure s))
Hmul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) (_ : x * y ∈ closure s)
x : M
hx : x ∈ closure s
⊢ p x hx

tactic: exact
  closure_induction hx (fun x hx => ⟨_, Hs x hx⟩) fun x y ⟨hx', hx⟩ ⟨hy', hy⟩ =>
    ⟨_, Hmul _ _ _ _ hx hy⟩
state_before: M : Type u_1
N : Type ?u.16694
A : Type ?u.16697
inst✝¹ : Mul M
s✝ : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
s : Set M
p : (x : M) → x ∈ closure s → Prop
Hs : ∀ (x : M) (h : x ∈ s), p x (_ : x ∈ ↑(closure s))
Hmul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) (_ : x * y ∈ closure s)
x : M
hx : x ∈ closure s
⊢ ∃ x_1, p x x_1
Theorem: CategoryTheory.Limits.biprod.mapBiprod_hom_desc
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean

tactic: rw [← biprod.mapBiprod_inv_map_desc, Iso.hom_inv_id_assoc]
state_before: C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
F : C ⥤ D
inst✝² : PreservesZeroMorphisms F
X Y : C
inst✝¹ : HasBinaryBiproduct X Y
inst✝ : PreservesBinaryBiproduct X Y F
W : C
f : X ⟶ W
g : Y ⟶ W
⊢ (mapBiprod F X Y).hom ≫ desc (F.map f) (F.map g) = F.map (desc f g)
Theorem: Nat.div_add_mod'
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [mul_comm]
state_before: m✝ n k✝ m k : ℕ
⊢ m / k * k + m % k = m

tactic: exact div_add_mod _ _
state_before: m✝ n k✝ m k : ℕ
⊢ k * (m / k) + m % k = m
Theorem: List.tail_replicate
File: Mathlib/Data/List/Basic.lean

tactic: cases n <;> rfl
state_before: ι : Type ?u.19246
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
n : ℕ
⊢ tail (replicate n a) = replicate (n - 1) a
Theorem: Set.image_inf_prod
File: Mathlib/Data/Set/Sups.lean

tactic: rw [← this]
state_before: α : Type u_1
inst✝ : SemilatticeInf α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Set α
a b c : α
s t : Set α
this : (uncurry fun x x_1 => x ⊓ x_1) '' s ×ˢ t = image2 (fun x x_1 => x ⊓ x_1) s t
⊢ image2 (fun x x_1 => x ⊓ x_1) s t = s ⊼ t

tactic: exact image_uncurry_prod _ _ _
state_before: α : Type u_1
inst✝ : SemilatticeInf α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Set α
a b c : α
s t : Set α
this : (uncurry fun x x_1 => x ⊓ x_1) '' s ×ˢ t = image2 (fun x x_1 => x ⊓ x_1) s t
⊢ (uncurry fun x x_1 => x ⊓ x_1) '' s ×ˢ t = s ⊼ t

tactic: simp only [@ge_iff_le, @Set.image_uncurry_prod]
state_before: α : Type u_1
inst✝ : SemilatticeInf α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Set α
a b c : α
s t : Set α
⊢ (uncurry fun x x_1 => x ⊓ x_1) '' s ×ˢ t = image2 (fun x x_1 => x ⊓ x_1) s t
Theorem: List.alternatingProd_cons_cons
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: rw [div_eq_mul_inv, alternatingProd_cons_cons']
state_before: ι : Type ?u.162207
α : Type u_1
M : Type ?u.162213
N : Type ?u.162216
P : Type ?u.162219
M₀ : Type ?u.162222
G : Type ?u.162225
R : Type ?u.162228
inst✝ : DivInvMonoid α
a b : α
l : List α
⊢ alternatingProd (a :: b :: l) = a / b * alternatingProd l
Theorem: Multiset.map_add_left_Ioc
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: classical rw [Ioc, Ioc, ← Finset.image_add_left_Ioc, Finset.image_val,
    ((Finset.nodup _).map <| add_right_injective c).dedup]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map ((fun x x_1 => x + x_1) c) (Ioc a b) = Ioc (c + a) (c + b)

tactic: rw [Ioc, Ioc, ← Finset.image_add_left_Ioc, Finset.image_val,
((Finset.nodup _).map <| add_right_injective c).dedup]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map ((fun x x_1 => x + x_1) c) (Ioc a b) = Ioc (c + a) (c + b)
Theorem: Nat.leRecOn_succ
File: Mathlib/Data/Nat/Basic.lean

tactic: conv =>
  lhs
  rw [leRecOn, Or.by_cases, dif_pos h1]
state_before: m✝ n✝ k : ℕ
C : ℕ → Sort u
n m : ℕ
h1 : n ≤ m
h2 : n ≤ m + 1
next : {k : ℕ} → C k → C (k + 1)
x : C n
⊢ leRecOn h2 next x = next (leRecOn h1 next x)
Theorem: ENNReal.smul_sSup
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp_rw [← smul_one_mul c (sSup s), ENNReal.mul_sSup, smul_one_mul]
state_before: α : Type ?u.158034
β : Type ?u.158037
γ : Type ?u.158040
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
R : Type u_1
inst✝¹ : SMul R ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
s : Set ℝ≥0∞
c : R
⊢ c • sSup s = ⨆ (i : ℝ≥0∞) (_ : i ∈ s), c • i
Theorem: Qpf.Fix.ind
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: apply Quot.ind
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
p : Fix F → Prop
h : ∀ (x : F (Fix F)), Liftp p x → p (mk x)
⊢ ∀ (x : Fix F), p x

tactic: intro x
state_before: case mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
p : Fix F → Prop
h : ∀ (x : F (Fix F)), Liftp p x → p (mk x)
⊢ ∀ (a : PFunctor.W (P F)), p (Quot.mk Setoid.r a)

tactic: induction' x with a f ih
state_before: case mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
p : Fix F → Prop
h : ∀ (x : F (Fix F)), Liftp p x → p (mk x)
x : PFunctor.W (P F)
⊢ p (Quot.mk Setoid.r x)

tactic: change p ⟦⟨a, f⟩⟧
state_before: case mk.mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
p : Fix F → Prop
h : ∀ (x : F (Fix F)), Liftp p x → p (mk x)
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), p (Quot.mk Setoid.r (f a))
⊢ p (Quot.mk Setoid.r (WType.mk a f))

tactic: rw [← Fix.ind_aux a f]
state_before: case mk.mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
p : Fix F → Prop
h : ∀ (x : F (Fix F)), Liftp p x → p (mk x)
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), p (Quot.mk Setoid.r (f a))
⊢ p (Quotient.mk Wsetoid (WType.mk a f))

tactic: apply h
state_before: case mk.mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
p : Fix F → Prop
h : ∀ (x : F (Fix F)), Liftp p x → p (mk x)
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), p (Quot.mk Setoid.r (f a))
⊢ p (mk (abs { fst := a, snd := fun x => Quotient.mk Wsetoid (f x) }))

tactic: rw [liftp_iff]
state_before: case mk.mk.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
p : Fix F → Prop
h : ∀ (x : F (Fix F)), Liftp p x → p (mk x)
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), p (Quot.mk Setoid.r (f a))
⊢ Liftp p (abs { fst := a, snd := fun x => Quotient.mk Wsetoid (f x) })

tactic: refine' ⟨_, _, rfl, _⟩
state_before: case mk.mk.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
p : Fix F → Prop
h : ∀ (x : F (Fix F)), Liftp p x → p (mk x)
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), p (Quot.mk Setoid.r (f a))
⊢ ∃ a_1 f_1,
    abs { fst := a, snd := fun x => Quotient.mk Wsetoid (f x) } = abs { fst := a_1, snd := f_1 } ∧
      ∀ (i : PFunctor.B (P F) a_1), p (f_1 i)

tactic: convert ih
state_before: case mk.mk.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
p : Fix F → Prop
h : ∀ (x : F (Fix F)), Liftp p x → p (mk x)
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), p (Quot.mk Setoid.r (f a))
⊢ ∀ (i : PFunctor.B (P F) a), p (Quotient.mk Wsetoid (f i))
Theorem: Finset.sort_nodup
File: Mathlib/Data/Finset/Sort.lean

tactic: rw [sort_eq]
state_before: α : Type u_1
β : Type ?u.1443
r : α → α → Prop
inst✝³ : DecidableRel r
inst✝² : IsTrans α r
inst✝¹ : IsAntisymm α r
inst✝ : IsTotal α r
s : Finset α
⊢ Nodup ↑(sort r s)

tactic: exact s.2
state_before: α : Type u_1
β : Type ?u.1443
r : α → α → Prop
inst✝³ : DecidableRel r
inst✝² : IsTrans α r
inst✝¹ : IsAntisymm α r
inst✝ : IsTotal α r
s : Finset α
⊢ Nodup s.val
Theorem: Fin.cast_castAdd_left
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n✝ m✝ n n' m : ℕ
i : Fin n'
h : n' + m = n + m
⊢ ↑(cast h) (↑(castAdd m) i) = ↑(castAdd m) (↑(cast (_ : n' = n)) i)

tactic: simp
state_before: case h
n✝ m✝ n n' m : ℕ
i : Fin n'
h : n' + m = n + m
⊢ ↑(↑(cast h) (↑(castAdd m) i)) = ↑(↑(castAdd m) (↑(cast (_ : n' = n)) i))
Theorem: RingSubgroupsBasis.nonarchimedean
File: Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean

tactic: letI := hB.topology
state_before: A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
⊢ NonarchimedeanRing A

tactic: constructor
state_before: A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
this : TopologicalSpace A := topology hB
⊢ NonarchimedeanRing A

tactic: intro U hU
state_before: case is_nonarchimedean
A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
this : TopologicalSpace A := topology hB
⊢ ∀ (U : Set A), U ∈ 𝓝 0 → ∃ V, ↑V ⊆ U

tactic: obtain ⟨i, -, hi : (B i : Set A) ⊆ U⟩ := hB.hasBasis_nhds_zero.mem_iff.mp hU
state_before: case is_nonarchimedean
A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
this : TopologicalSpace A := topology hB
U : Set A
hU : U ∈ 𝓝 0
⊢ ∃ V, ↑V ⊆ U

tactic: exact ⟨hB.openAddSubgroup i, hi⟩
state_before: case is_nonarchimedean.intro.intro
A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
this : TopologicalSpace A := topology hB
U : Set A
hU : U ∈ 𝓝 0
i : ι
hi : ↑(B i) ⊆ U
⊢ ∃ V, ↑V ⊆ U
Theorem: CategoryTheory.Limits.prod.leftUnitor_inv_naturality
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv, prod.leftUnitor_hom_naturality]
state_before: C : Type u
inst✝² : Category C
X Y : C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
f : X ⟶ Y
⊢ (leftUnitor X).inv ≫ map (𝟙 (⊤_ C)) f = f ≫ (leftUnitor Y).inv
Theorem: Subsemigroup.le_prod_iff
File: Mathlib/GroupTheory/Subsemigroup/Operations.lean

tactic: constructor
state_before: M : Type u_1
N : Type u_2
P : Type ?u.58318
σ : Type ?u.58321
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S s : Subsemigroup M
t : Subsemigroup N
u : Subsemigroup (M × N)
⊢ u ≤ prod s t ↔ map (fst M N) u ≤ s ∧ map (snd M N) u ≤ t

tactic: intro h
state_before: case mp
M : Type u_1
N : Type u_2
P : Type ?u.58318
σ : Type ?u.58321
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S s : Subsemigroup M
t : Subsemigroup N
u : Subsemigroup (M × N)
⊢ u ≤ prod s t → map (fst M N) u ≤ s ∧ map (snd M N) u ≤ t

tactic: constructor
state_before: case mp
M : Type u_1
N : Type u_2
P : Type ?u.58318
σ : Type ?u.58321
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S s : Subsemigroup M
t : Subsemigroup N
u : Subsemigroup (M × N)
h : u ≤ prod s t
⊢ map (fst M N) u ≤ s ∧ map (snd M N) u ≤ t

tactic: rintro x ⟨⟨y1, y2⟩, ⟨hy1, rfl⟩⟩
state_before: case mp.left
M : Type u_1
N : Type u_2
P : Type ?u.58318
σ : Type ?u.58321
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S s : Subsemigroup M
t : Subsemigroup N
u : Subsemigroup (M × N)
h : u ≤ prod s t
⊢ map (fst M N) u ≤ s

tactic: exact (h hy1).1
state_before: case mp.left.intro.mk.intro
M : Type u_1
N : Type u_2
P : Type ?u.58318
σ : Type ?u.58321
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S s : Subsemigroup M
t : Subsemigroup N
u : Subsemigroup (M × N)
h : u ≤ prod s t
y1 : M
y2 : N
hy1 : (y1, y2) ∈ ↑u
⊢ ↑(fst M N) (y1, y2) ∈ s

tactic: rintro x ⟨⟨y1, y2⟩, ⟨hy1, rfl⟩⟩
state_before: case mp.right
M : Type u_1
N : Type u_2
P : Type ?u.58318
σ : Type ?u.58321
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S s : Subsemigroup M
t : Subsemigroup N
u : Subsemigroup (M × N)
h : u ≤ prod s t
⊢ map (snd M N) u ≤ t

tactic: exact (h hy1).2
state_before: case mp.right.intro.mk.intro
M : Type u_1
N : Type u_2
P : Type ?u.58318
σ : Type ?u.58321
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S s : Subsemigroup M
t : Subsemigroup N
u : Subsemigroup (M × N)
h : u ≤ prod s t
y1 : M
y2 : N
hy1 : (y1, y2) ∈ ↑u
⊢ ↑(snd M N) (y1, y2) ∈ t

tactic: rintro ⟨hH, hK⟩ ⟨x1, x2⟩ h
state_before: case mpr
M : Type u_1
N : Type u_2
P : Type ?u.58318
σ : Type ?u.58321
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S s : Subsemigroup M
t : Subsemigroup N
u : Subsemigroup (M × N)
⊢ map (fst M N) u ≤ s ∧ map (snd M N) u ≤ t → u ≤ prod s t

tactic: exact ⟨hH ⟨_, h, rfl⟩, hK ⟨_, h, rfl⟩⟩
state_before: case mpr.intro.mk
M : Type u_1
N : Type u_2
P : Type ?u.58318
σ : Type ?u.58321
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S s : Subsemigroup M
t : Subsemigroup N
u : Subsemigroup (M × N)
hH : map (fst M N) u ≤ s
hK : map (snd M N) u ≤ t
x1 : M
x2 : N
h : (x1, x2) ∈ u
⊢ (x1, x2) ∈ prod s t
Theorem: OmegaCompletePartialOrder.ContinuousHom.comp_id
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: ext
state_before: α : Type u
α' : Type ?u.65611
β : Type v
β' : Type ?u.65616
γ : Type u_1
φ : Type ?u.65622
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
f : β →𝒄 γ
⊢ comp f id = f

tactic: rfl
state_before: case h
α : Type u
α' : Type ?u.65611
β : Type v
β' : Type ?u.65616
γ : Type u_1
φ : Type ?u.65622
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
f : β →𝒄 γ
x✝ : β
⊢ ↑(comp f id).toOrderHom x✝ = ↑f.toOrderHom x✝
Theorem: BoxIntegral.norm_integral_le_of_le_const
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: simpa only [integral_const] using norm_integral_le_of_norm_le hc μ (integrable_const c)
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝¹ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c : ℝ
hc : ∀ (x : ι → ℝ), x ∈ ↑Box.Icc I → ‖f x‖ ≤ c
μ : MeasureTheory.Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
⊢ ‖integral I l f (BoxAdditiveMap.toSMul (Measure.toBoxAdditive μ))‖ ≤ ENNReal.toReal (↑↑μ ↑I) * c