tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.OuterMeasure.biInf_apply'
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp only [← iInf_subtype'', iInf_apply' _ hs]
state_before: α : Type u_2
ι : Type u_1
I : Set ι
m : ι → OuterMeasure α
s : Set α
hs : Set.Nonempty s
⊢ ↑(⨅ (i : ι) (_ : i ∈ I), m i) s =
    ⨅ (t : ℕ → Set α) (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ (i : ι) (_ : i ∈ I), ↑(m i) (t n)
Theorem: MvPowerSeries.X_inv
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [inv_eq_zero, constantCoeff_X]
state_before: σ : Type u_1
R : Type ?u.2011299
k : Type u_2
inst✝ : Field k
s : σ
⊢ (X s)⁻¹ = 0
Theorem: CategoryTheory.Idempotents.Karoubi.eqToHom_f
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: subst h
state_before: C : Type u_1
inst✝ : Category C
P Q : Karoubi C
h : P = Q
⊢ (eqToHom h).f = P.p ≫ eqToHom (_ : P.X = Q.X)

tactic: simp only [eqToHom_refl, Karoubi.id_eq, comp_id]
state_before: C : Type u_1
inst✝ : Category C
P : Karoubi C
⊢ (eqToHom (_ : P = P)).f = P.p ≫ eqToHom (_ : P.X = P.X)
Theorem: CategoryTheory.Limits.cokernel_not_iso_of_nonzero
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: skip
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasCokernel f
w : f ≠ 0
I : IsIso (cokernel.π f)
⊢ Mono (cokernel.π f)

tactic: infer_instance
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasCokernel f
w : f ≠ 0
I : IsIso (cokernel.π f)
⊢ Mono (cokernel.π f)
Theorem: Nat.minSqFac_prime
File: Mathlib/Data/Nat/Squarefree.lean

tactic: have := minSqFac_has_prop n
state_before: n d : ℕ
h : minSqFac n = some d
⊢ Prime d

tactic: rw [h] at this
state_before: n d : ℕ
h : minSqFac n = some d
this : MinSqFacProp n (minSqFac n)
⊢ Prime d

tactic: exact this.1
state_before: n d : ℕ
h : minSqFac n = some d
this : MinSqFacProp n (some d)
⊢ Prime d
Theorem: sSup_inf_eq
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simpa only [inf_comm] using @inf_sSup_eq α _ s b
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort ?u.1710
inst✝ : Frame α
s t : Set α
a b : α
⊢ sSup s ⊓ b = ⨆ (a : α) (_ : a ∈ s), a ⊓ b
Theorem: Trivialization.continuousAt_of_comp_right
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: have hez : z ∈ e.toLocalEquiv.symm.target := by
  rw [LocalEquiv.symm_target, e.mem_source]
  exact he
state_before: ι : Type ?u.42663
B : Type u_2
F : Type u_3
E : B → Type ?u.42674
Z : Type u_4
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace F
proj : Z → B
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F proj
x : Z
X : Type u_1
inst✝ : TopologicalSpace X
f : Z → X
z : Z
e : Trivialization F proj
he : proj z ∈ e.baseSet
hf : ContinuousAt (f ∘ ↑(LocalEquiv.symm e.toLocalEquiv)) (↑e z)
⊢ ContinuousAt f z

tactic: rwa [e.toLocalHomeomorph.symm.continuousAt_iff_continuousAt_comp_right hez,
  LocalHomeomorph.symm_symm]
state_before: ι : Type ?u.42663
B : Type u_2
F : Type u_3
E : B → Type ?u.42674
Z : Type u_4
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace F
proj : Z → B
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F proj
x : Z
X : Type u_1
inst✝ : TopologicalSpace X
f : Z → X
z : Z
e : Trivialization F proj
he : proj z ∈ e.baseSet
hf : ContinuousAt (f ∘ ↑(LocalEquiv.symm e.toLocalEquiv)) (↑e z)
hez : z ∈ (LocalEquiv.symm e.toLocalEquiv).target
⊢ ContinuousAt f z

tactic: rw [LocalEquiv.symm_target, e.mem_source]
state_before: ι : Type ?u.42663
B : Type u_2
F : Type u_3
E : B → Type ?u.42674
Z : Type u_4
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace F
proj : Z → B
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F proj
x : Z
X : Type u_1
inst✝ : TopologicalSpace X
f : Z → X
z : Z
e : Trivialization F proj
he : proj z ∈ e.baseSet
hf : ContinuousAt (f ∘ ↑(LocalEquiv.symm e.toLocalEquiv)) (↑e z)
⊢ z ∈ (LocalEquiv.symm e.toLocalEquiv).target

tactic: exact he
state_before: ι : Type ?u.42663
B : Type u_2
F : Type u_3
E : B → Type ?u.42674
Z : Type u_4
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace F
proj : Z → B
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F proj
x : Z
X : Type u_1
inst✝ : TopologicalSpace X
f : Z → X
z : Z
e : Trivialization F proj
he : proj z ∈ e.baseSet
hf : ContinuousAt (f ∘ ↑(LocalEquiv.symm e.toLocalEquiv)) (↑e z)
⊢ proj z ∈ e.baseSet
Theorem: TopCat.sigmaIsoSigma_hom_ι
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

tactic: simp [sigmaIsoSigma]
state_before: J : Type v
inst✝ : SmallCategory J
ι : Type v
α : ι → TopCatMax
i : ι
⊢ Sigma.ι α i ≫ (sigmaIsoSigma α).hom = sigmaι α i
Theorem: MvPolynomial.eval₂_map
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [← eval_map, ← eval_map, map_map]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : R →+* S₁
inst✝ : CommSemiring S₂
f : R →+* S₁
g : σ → S₂
φ : S₁ →+* S₂
p : MvPolynomial σ R
⊢ eval₂ φ g (↑(map f) p) = eval₂ (RingHom.comp φ f) g p
Theorem: Nat.Primrec'.prim_iff₂
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: f : ℕ → ℕ → ℕ
h : Primrec fun v => f (Vector.head v) (Vector.head (Vector.tail v))
v : ℕ × ℕ
⊢ f (Vector.head (v.fst ::ᵥ v.snd ::ᵥ nil)) (Vector.head (Vector.tail (v.fst ::ᵥ v.snd ::ᵥ nil))) = f v.fst v.snd
Theorem: Nat.eq_zero_of_le_div
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rw [mul_comm]
state_before: m n k l : ℕ
hn : 2 ≤ n
h : m ≤ m / n
⊢ n * m ≤ m

tactic: exact (Nat.le_div_iff_mul_le' (lt_of_lt_of_le (by decide) hn)).1 h
state_before: m n k l : ℕ
hn : 2 ≤ n
h : m ≤ m / n
⊢ m * n ≤ m

tactic: decide
state_before: m n k l : ℕ
hn : 2 ≤ n
h : m ≤ m / n
⊢ 0 < 2
Theorem: isSeparable_tower_bot_of_isSeparable
File: Mathlib/FieldTheory/Separable.lean

tactic: refine'
  (isSeparable_iff.1 h (algebraMap K E x)).imp isIntegral_tower_bot_of_isIntegral_field
    fun hs => _
state_before: F : Type u_1
K : Type u_3
E : Type u_2
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field E
inst✝³ : Algebra F K
inst✝² : Algebra F E
inst✝¹ : Algebra K E
inst✝ : IsScalarTower F K E
h : IsSeparable F E
x : K
⊢ IsIntegral F x ∧ Separable (minpoly F x)

tactic: obtain ⟨q, hq⟩ :=
  minpoly.dvd F x
    ((aeval_algebraMap_eq_zero_iff _ _ _).mp (minpoly.aeval F ((algebraMap K E) x)))
state_before: F : Type u_1
K : Type u_3
E : Type u_2
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field E
inst✝³ : Algebra F K
inst✝² : Algebra F E
inst✝¹ : Algebra K E
inst✝ : IsScalarTower F K E
h : IsSeparable F E
x : K
hs : Separable (minpoly F (↑(algebraMap K E) x))
⊢ Separable (minpoly F x)

tactic: rw [hq] at hs
state_before: case intro
F : Type u_1
K : Type u_3
E : Type u_2
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field E
inst✝³ : Algebra F K
inst✝² : Algebra F E
inst✝¹ : Algebra K E
inst✝ : IsScalarTower F K E
h : IsSeparable F E
x : K
hs : Separable (minpoly F (↑(algebraMap K E) x))
q : F[X]
hq : minpoly F (↑(algebraMap K E) x) = minpoly F x * q
⊢ Separable (minpoly F x)

tactic: exact hs.of_mul_left
state_before: case intro
F : Type u_1
K : Type u_3
E : Type u_2
inst✝⁶ : Field F
inst✝⁵ : Field K
inst✝⁴ : Field E
inst✝³ : Algebra F K
inst✝² : Algebra F E
inst✝¹ : Algebra K E
inst✝ : IsScalarTower F K E
h : IsSeparable F E
x : K
q : F[X]
hs : Separable (minpoly F x * q)
hq : minpoly F (↑(algebraMap K E) x) = minpoly F x * q
⊢ Separable (minpoly F x)
Theorem: Fintype.piFinset_empty
File: Mathlib/Data/Fintype/Pi.lean

tactic: simp
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
δ : α → Type u_2
inst✝ : Nonempty α
x✝ : (a : α) → δ a
⊢ ¬x✝ ∈ piFinset fun x => ∅
Theorem: LeftOrdContinuous.iterate
File: Mathlib/Order/OrdContinuous.lean

tactic: induction n with
| zero => exact LeftOrdContinuous.id α
| succ n ihn => exact ihn.comp hf
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
g : β → γ
f✝ : α → β
f : α → α
hf : LeftOrdContinuous f
n : ℕ
⊢ LeftOrdContinuous (f^[n])

tactic: exact LeftOrdContinuous.id α
state_before: case zero
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
g : β → γ
f✝ : α → β
f : α → α
hf : LeftOrdContinuous f
⊢ LeftOrdContinuous (f^[Nat.zero])

tactic: exact ihn.comp hf
state_before: case succ
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
g : β → γ
f✝ : α → β
f : α → α
hf : LeftOrdContinuous f
n : ℕ
ihn : LeftOrdContinuous (f^[n])
⊢ LeftOrdContinuous (f^[Nat.succ n])
Theorem: LatticeOrderedCommGroup.pos_mul_neg
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: rw [m_pos_part_def, sup_mul, one_mul, m_neg_part_def, mul_sup, mul_one, mul_inv_self, sup_assoc,
  ← @sup_assoc _ _ a, sup_eq_right.2 le_sup_right]
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ abs a = a⁺ * a⁻

tactic: exact (sup_eq_left.2 <| one_le_abs a).symm
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ abs a = a ⊔ a⁻¹ ⊔ 1
Theorem: CategoryTheory.Limits.prod.lift_fst_snd
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: apply prod.hom_ext
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryProduct X Y
⊢ lift fst snd = 𝟙 (X ⨯ Y)

tactic: simp
state_before: case h₁
C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryProduct X Y
⊢ lift fst snd ≫ fst = 𝟙 (X ⨯ Y) ≫ fst

case h₂
C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryProduct X Y
⊢ lift fst snd ≫ snd = 𝟙 (X ⨯ Y) ≫ snd

tactic: simp
state_before: case h₂
C : Type u
inst✝¹ : Category C
X✝ Y✝ X Y : C
inst✝ : HasBinaryProduct X Y
⊢ lift fst snd ≫ snd = 𝟙 (X ⨯ Y) ≫ snd
Theorem: CategoryTheory.GlueData.ι_gluedIso_inv
File: Mathlib/CategoryTheory/GlueData.lean

tactic: rw [Iso.comp_inv_eq, ι_gluedIso_hom]
state_before: C : Type u₁
inst✝³ : Category C
C' : Type u₂
inst✝² : Category C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
⊢ ι (mapGlueData D F) i ≫ (gluedIso D F).inv = F.map (ι D i)
Theorem: CategoryTheory.kernel_comp_cokernel
File: Mathlib/Algebra/Homology/Exact.lean

tactic: suffices Subobject.arrow (kernelSubobject g) ≫ cokernel.π f = 0 by
  rw [← kernelSubobject_arrow', Category.assoc, this, comp_zero]
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : HasCokernels V
h : Exact f g
⊢ kernel.ι g ≫ cokernel.π f = 0

tactic: haveI := h.epi
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : HasCokernels V
h : Exact f g
⊢ Subobject.arrow (kernelSubobject g) ≫ cokernel.π f = 0

tactic: apply zero_of_epi_comp (imageToKernel f g h.w) _
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : HasCokernels V
h : Exact f g
this : Epi (imageToKernel f g (_ : f ≫ g = 0))
⊢ Subobject.arrow (kernelSubobject g) ≫ cokernel.π f = 0

tactic: rw [imageToKernel_arrow_assoc, ← imageSubobject_arrow, Category.assoc, ← Iso.eq_inv_comp]
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : HasCokernels V
h : Exact f g
this : Epi (imageToKernel f g (_ : f ≫ g = 0))
⊢ imageToKernel f g (_ : f ≫ g = 0) ≫ Subobject.arrow (kernelSubobject g) ≫ cokernel.π f = 0

tactic: aesop_cat
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : HasCokernels V
h : Exact f g
this : Epi (imageToKernel f g (_ : f ≫ g = 0))
⊢ image.ι f ≫ cokernel.π f = (imageSubobjectIso f).inv ≫ 0

tactic: rw [← kernelSubobject_arrow', Category.assoc, this, comp_zero]
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : HasCokernels V
h : Exact f g
this : Subobject.arrow (kernelSubobject g) ≫ cokernel.π f = 0
⊢ kernel.ι g ≫ cokernel.π f = 0
Theorem: Set.ssubset_toFinset
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [← Finset.coe_ssubset, coe_toFinset]
state_before: α : Type u_1
β : Type ?u.84731
γ : Type ?u.84734
s✝ t : Set α
s : Finset α
inst✝ : Fintype ↑t
⊢ s ⊂ toFinset t ↔ ↑s ⊂ t
Theorem: LieIdeal.map_comap_incl
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: conv_rhs => rw [← I₁.incl_idealRange]
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ map (incl I₁) (comap (incl I₁) I₂) = I₁ ⊓ I₂

tactic: rw [← map_comap_eq]
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ map (incl I₁) (comap (incl I₁) I₂) = LieHom.idealRange (incl I₁) ⊓ I₂

tactic: exact I₁.incl_isIdealMorphism
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ LieHom.IsIdealMorphism (incl I₁)
Theorem: AlgebraicGeometry.LocallyRingedSpace.basicOpen_zero
File: Mathlib/AlgebraicGeometry/LocallyRingedSpace.lean

tactic: ext x
state_before: X✝ : LocallyRingedSpace
X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
⊢ RingedSpace.basicOpen (toRingedSpace X) 0 = ⊥

tactic: simp only [RingedSpace.basicOpen, Opens.coe_mk, Set.mem_image, Set.mem_setOf_eq, Subtype.exists,
  exists_and_right, exists_eq_right, Opens.coe_bot, Set.mem_empty_iff_false,
  iff_false, not_exists]
state_before: case h.h
X✝ : LocallyRingedSpace
X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑(toRingedSpace X).toPresheafedSpace
⊢ x ∈ ↑(RingedSpace.basicOpen (toRingedSpace X) 0) ↔ x ∈ ↑⊥

tactic: intros hx
state_before: case h.h
X✝ : LocallyRingedSpace
X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑(toRingedSpace X).toPresheafedSpace
⊢ ∀ (x_1 : x ∈ U),
    ¬IsUnit (↑(Presheaf.germ (toRingedSpace X).toPresheafedSpace.presheaf { val := x, property := (_ : x ∈ U) }) 0)

tactic: rw [map_zero, isUnit_zero_iff]
state_before: case h.h
X✝ : LocallyRingedSpace
X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑(toRingedSpace X).toPresheafedSpace
hx : x ∈ U
⊢ ¬IsUnit (↑(Presheaf.germ (toRingedSpace X).toPresheafedSpace.presheaf { val := x, property := (_ : x ∈ U) }) 0)

tactic: change (0 : X.stalk x) ≠ (1 : X.stalk x)
state_before: case h.h
X✝ : LocallyRingedSpace
X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑(toRingedSpace X).toPresheafedSpace
hx : x ∈ U
⊢ ¬0 = 1

tactic: exact zero_ne_one
state_before: case h.h
X✝ : LocallyRingedSpace
X : LocallyRingedSpace
U : Opens ↑↑X.toPresheafedSpace
x : ↑↑(toRingedSpace X).toPresheafedSpace
hx : x ∈ U
⊢ 0 ≠ 1
Theorem: ContinuousMultilinearMap.uncurry0_norm
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: simp
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 (fun i => G) G'
⊢ ‖uncurry0 f‖ = ‖f‖
Theorem: Qpf.Wequiv.symm
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: intro h
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x y : PFunctor.W (P F)
⊢ Wequiv x y → Wequiv y x

tactic: induction h
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x y : PFunctor.W (P F)
h : Wequiv x y
⊢ Wequiv y x

tactic: case ind a f f' _ ih => exact Wequiv.ind _ _ _ ih
state_before: case ind
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x y : PFunctor.W (P F)
a✝¹ : (P F).A
f✝ f'✝ : PFunctor.B (P F) a✝¹ → PFunctor.W (P F)
a✝ : ∀ (x : PFunctor.B (P F) a✝¹), Wequiv (f✝ x) (f'✝ x)
a_ih✝ : ∀ (x : PFunctor.B (P F) a✝¹), Wequiv (f'✝ x) (f✝ x)
⊢ Wequiv (WType.mk a✝¹ f'✝) (WType.mk a✝¹ f✝)

case abs
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x y : PFunctor.W (P F)
a✝¹ : (P F).A
f✝ : PFunctor.B (P F) a✝¹ → PFunctor.W (P F)
a'✝ : (P F).A
f'✝ : PFunctor.B (P F) a'✝ → PFunctor.W (P F)
a✝ : Qpf.abs { fst := a✝¹, snd := f✝ } = Qpf.abs { fst := a'✝, snd := f'✝ }
⊢ Wequiv (WType.mk a'✝ f'✝) (WType.mk a✝¹ f✝)

case trans
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x y u✝ v✝ w✝ : PFunctor.W (P F)
a✝¹ : Wequiv u✝ v✝
a✝ : Wequiv v✝ w✝
a_ih✝¹ : Wequiv v✝ u✝
a_ih✝ : Wequiv w✝ v✝
⊢ Wequiv w✝ u✝

tactic: case abs a f a' f' h => exact Wequiv.abs _ _ _ _ h.symm
state_before: case abs
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x y : PFunctor.W (P F)
a✝¹ : (P F).A
f✝ : PFunctor.B (P F) a✝¹ → PFunctor.W (P F)
a'✝ : (P F).A
f'✝ : PFunctor.B (P F) a'✝ → PFunctor.W (P F)
a✝ : Qpf.abs { fst := a✝¹, snd := f✝ } = Qpf.abs { fst := a'✝, snd := f'✝ }
⊢ Wequiv (WType.mk a'✝ f'✝) (WType.mk a✝¹ f✝)

case trans
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x y u✝ v✝ w✝ : PFunctor.W (P F)
a✝¹ : Wequiv u✝ v✝
a✝ : Wequiv v✝ w✝
a_ih✝¹ : Wequiv v✝ u✝
a_ih✝ : Wequiv w✝ v✝
⊢ Wequiv w✝ u✝

tactic: case trans x y z _ _ ih₁ ih₂ => exact Qpf.Wequiv.trans _ _ _ ih₂ ih₁
state_before: case trans
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x y u✝ v✝ w✝ : PFunctor.W (P F)
a✝¹ : Wequiv u✝ v✝
a✝ : Wequiv v✝ w✝
a_ih✝¹ : Wequiv v✝ u✝
a_ih✝ : Wequiv w✝ v✝
⊢ Wequiv w✝ u✝

tactic: exact Wequiv.ind _ _ _ ih
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x y : PFunctor.W (P F)
a : (P F).A
f f' : PFunctor.B (P F) a → PFunctor.W (P F)
a✝ : ∀ (x : PFunctor.B (P F) a), Wequiv (f x) (f' x)
ih : ∀ (x : PFunctor.B (P F) a), Wequiv (f' x) (f x)
⊢ Wequiv (WType.mk a f') (WType.mk a f)

tactic: exact Wequiv.abs _ _ _ _ h.symm
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x y : PFunctor.W (P F)
a : (P F).A
f : PFunctor.B (P F) a → PFunctor.W (P F)
a' : (P F).A
f' : PFunctor.B (P F) a' → PFunctor.W (P F)
h : Qpf.abs { fst := a, snd := f } = Qpf.abs { fst := a', snd := f' }
⊢ Wequiv (WType.mk a' f') (WType.mk a f)

tactic: exact Qpf.Wequiv.trans _ _ _ ih₂ ih₁
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x✝ y✝ x y z : PFunctor.W (P F)
a✝¹ : Wequiv x y
a✝ : Wequiv y z
ih₁ : Wequiv y x
ih₂ : Wequiv z y
⊢ Wequiv z x
Theorem: CategoryTheory.Limits.PullbackCone.mono_of_isLimitMkIdId
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rcases PullbackCone.IsLimit.lift' t _ _ eq with ⟨_, rfl, rfl⟩
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X Y Z✝ : C
f✝ : X ⟶ Z✝
g✝ : Y ⟶ Z✝
f : X ⟶ Y
t : IsLimit (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f))
Z : C
g h : Z ⟶ X
eq : g ≫ f = h ≫ f
⊢ g = h

tactic: rfl
state_before: case mk.intro
C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W X Y Z✝ : C
f✝ : X ⟶ Z✝
g : Y ⟶ Z✝
f : X ⟶ Y
t : IsLimit (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f))
Z : C
val✝ : Z ⟶ (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f)).pt
eq :
  (val✝ ≫ fst (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f))) ≫ f = (val✝ ≫ snd (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f))) ≫ f
⊢ val✝ ≫ fst (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f)) = val✝ ≫ snd (mk (𝟙 X) (𝟙 X) (_ : 𝟙 X ≫ f = 𝟙 X ≫ f))
Theorem: Int.one_mul
File: Std/Data/Int/Lemmas.lean

tactic: rw [Nat.one_mul]
state_before: n : Nat
⊢ ofNat (1 * n) = ofNat n

tactic: rw [Nat.one_mul]
state_before: n : Nat
⊢ -[1 * n+1] = -[n+1]
Theorem: Finset.mem_mulAntidiagonal
File: Mathlib/Data/Finset/MulAntidiagonal.lean

tactic: simp only [mulAntidiagonal, Set.Finite.mem_toFinset, Set.mem_mulAntidiagonal]
state_before: α : Type u_1
inst✝ : OrderedCancelCommMonoid α
s t : Set α
hs : Set.IsPwo s
ht : Set.IsPwo t
a : α
u : Set α
hu : Set.IsPwo u
x : α × α
⊢ x ∈ mulAntidiagonal hs ht a ↔ x.fst ∈ s ∧ x.snd ∈ t ∧ x.fst * x.snd = a
Theorem: Int.subNatNat_elim
File: Std/Data/Int/Lemmas.lean

tactic: unfold subNatNat
state_before: m n : Nat
motive : Nat → Nat → Int → Prop
hp : ∀ (i n : Nat), motive (n + i) n ↑i
hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1]
⊢ motive m n (subNatNat m n)

tactic: match h : n - m with
| 0 =>
  have ⟨k, h⟩ := Nat.le.dest (Nat.le_of_sub_eq_zero h)
  rw [h.symm, Nat.add_sub_cancel_left]; apply hp
| succ k =>
  rw [Nat.sub_eq_iff_eq_add (Nat.le_of_lt (Nat.lt_of_sub_eq_succ h))] at h
  rw [h, Nat.add_comm]; apply hn
state_before: m n : Nat
motive : Nat → Nat → Int → Prop
hp : ∀ (i n : Nat), motive (n + i) n ↑i
hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1]
⊢ motive m n
    (match n - m with
    | 0 => ofNat (m - n)
    | succ k => -[k+1])

tactic: have ⟨k, h⟩ := Nat.le.dest (Nat.le_of_sub_eq_zero h)
state_before: m n : Nat
motive : Nat → Nat → Int → Prop
hp : ∀ (i n : Nat), motive (n + i) n ↑i
hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1]
h : n - m = 0
⊢ motive m n
    (match 0 with
    | 0 => ofNat (m - n)
    | succ k => -[k+1])

tactic: rw [h.symm, Nat.add_sub_cancel_left]
state_before: m n : Nat
motive : Nat → Nat → Int → Prop
hp : ∀ (i n : Nat), motive (n + i) n ↑i
hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1]
h✝ : n - m = 0
k : Nat
h : n + k = m
⊢ motive m n
    (match 0 with
    | 0 => ofNat (m - n)
    | succ k => -[k+1])

tactic: apply hp
state_before: m n : Nat
motive : Nat → Nat → Int → Prop
hp : ∀ (i n : Nat), motive (n + i) n ↑i
hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1]
h✝ : n - m = 0
k : Nat
h : n + k = m
⊢ motive (n + k) n
    (match 0 with
    | 0 => ofNat k
    | succ k => -[k+1])

tactic: rw [Nat.sub_eq_iff_eq_add (Nat.le_of_lt (Nat.lt_of_sub_eq_succ h))] at h
state_before: m n : Nat
motive : Nat → Nat → Int → Prop
hp : ∀ (i n : Nat), motive (n + i) n ↑i
hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1]
k : Nat
h : n - m = succ k
⊢ motive m n
    (match succ k with
    | 0 => ofNat (m - n)
    | succ k => -[k+1])

tactic: rw [h, Nat.add_comm]
state_before: m n : Nat
motive : Nat → Nat → Int → Prop
hp : ∀ (i n : Nat), motive (n + i) n ↑i
hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1]
k : Nat
h : n = succ k + m
⊢ motive m n
    (match succ k with
    | 0 => ofNat (m - n)
    | succ k => -[k+1])

tactic: apply hn
state_before: m n : Nat
motive : Nat → Nat → Int → Prop
hp : ∀ (i n : Nat), motive (n + i) n ↑i
hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1]
k : Nat
h : n = succ k + m
⊢ motive m (m + succ k)
    (match succ k with
    | 0 => ofNat (m - (m + succ k))
    | succ k => -[k+1])