tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.GrothendieckTopology.diagramCompIso_hom_ι
File: Mathlib/CategoryTheory/Sites/CompatiblePlus.lean

tactic: delta diagramCompIso
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w₁
inst✝⁴ : Category D
E : Type w₂
inst✝³ : Category E
F : D ⥤ E
inst✝² : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝¹ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
X : C
W : (Cover J X)ᵒᵖ
i : Cover.Arrow W.unop
⊢ (diagramCompIso J F P X).hom.app W ≫ Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i =
    F.map (Multiequalizer.ι (Cover.index W.unop P) i)

tactic: dsimp
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w₁
inst✝⁴ : Category D
E : Type w₂
inst✝³ : Category E
F : D ⥤ E
inst✝² : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝¹ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
X : C
W : (Cover J X)ᵒᵖ
i : Cover.Arrow W.unop
⊢ (NatIso.ofComponents fun W =>
              IsLimit.conePointUniqueUpToIso
                  (isLimitOfPreserves F (limit.isLimit (MulticospanIndex.multicospan (Cover.index W.unop P))))
                  (limit.isLimit (MulticospanIndex.multicospan (Cover.index W.unop P) ⋙ F)) ≪≫
                HasLimit.isoOfNatIso (Cover.multicospanComp F P W.unop).symm).hom.app
        W ≫
      Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i =
    F.map (Multiequalizer.ι (Cover.index W.unop P) i)

tactic: simp
state_before: C : Type u
inst✝⁵ : Category C
J : GrothendieckTopology C
D : Type w₁
inst✝⁴ : Category D
E : Type w₂
inst✝³ : Category E
F : D ⥤ E
inst✝² : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝¹ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
X : C
W : (Cover J X)ᵒᵖ
i : Cover.Arrow W.unop
⊢ ((IsLimit.conePointUniqueUpToIso
            (isLimitOfPreserves F (limit.isLimit (MulticospanIndex.multicospan (Cover.index W.unop P))))
            (limit.isLimit (MulticospanIndex.multicospan (Cover.index W.unop P) ⋙ F))).hom ≫
        (HasLimit.isoOfNatIso (Cover.multicospanComp F P W.unop).symm).hom) ≫
      Multiequalizer.ι (Cover.index W.unop (P ⋙ F)) i =
    F.map (Multiequalizer.ι (Cover.index W.unop P) i)
Theorem: Finset.support_mulAntidiagonal_subset_mul
File: Mathlib/Data/Finset/MulAntidiagonal.lean

tactic: rw [mem_mulAntidiagonal] at hb
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 : α × α
a : α
x✝ : a ∈ {a | Finset.Nonempty (mulAntidiagonal hs ht a)}
b : α × α
hb : b ∈ mulAntidiagonal hs ht a
⊢ a ∈ s * t

tactic: exact ⟨b.1, b.2, hb⟩
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 : α × α
a : α
x✝ : a ∈ {a | Finset.Nonempty (mulAntidiagonal hs ht a)}
b : α × α
hb : b.fst ∈ s ∧ b.snd ∈ t ∧ b.fst * b.snd = a
⊢ a ∈ s * t
Theorem: toIcoMod_eq_add_fract_mul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIcoMod, toIcoDiv_eq_floor, Int.fract]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ toIcoMod hp a b = a + Int.fract ((b - a) / p) * p

tactic: field_simp [hp.ne.symm]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ b - ⌊(b - a) / p⌋ • p = a + ((b - a) / p - ↑⌊(b - a) / p⌋) * p

tactic: ring
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ b - ↑⌊(b - a) / p⌋ * p = a + (b - a - p * ↑⌊(b - a) / p⌋)
Theorem: MeasureTheory.SimpleFunc.sum_range_measure_preimage_singleton
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [f.sum_measure_preimage_singleton, coe_range, preimage_range]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.33924
δ : Type ?u.33927
inst✝ : MeasurableSpace α
f : α →ₛ β
μ : Measure α
⊢ ∑ y in SimpleFunc.range f, ↑↑μ (↑f ⁻¹' {y}) = ↑↑μ univ
Theorem: AddMonoidAlgebra.of'_mul_modOf
File: Mathlib/Algebra/MonoidAlgebra/Division.lean

tactic: refine Finsupp.ext fun g' => ?_
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
g : G
x : AddMonoidAlgebra k G
⊢ of' k G g * x %ᵒᶠ g = 0

tactic: rw [Finsupp.zero_apply]
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
g : G
x : AddMonoidAlgebra k G
g' : G
⊢ ↑(of' k G g * x %ᵒᶠ g) g' = ↑0 g'

tactic: obtain ⟨d, rfl⟩ | h := em (∃ d, g' = g + d)
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
g : G
x : AddMonoidAlgebra k G
g' : G
⊢ ↑(of' k G g * x %ᵒᶠ g) g' = 0

tactic: rw [modOf_apply_self_add]
state_before: case inl.intro
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
g : G
x : AddMonoidAlgebra k G
d : G
⊢ ↑(of' k G g * x %ᵒᶠ g) (g + d) = 0

tactic: rw [modOf_apply_of_not_exists_add _ _ _ h, of'_apply, single_mul_apply_of_not_exists_add _ _ h]
state_before: case inr
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
g : G
x : AddMonoidAlgebra k G
g' : G
h : ¬∃ d, g' = g + d
⊢ ↑(of' k G g * x %ᵒᶠ g) g' = 0
Theorem: List.ofFn_eq_nil_iff
File: Mathlib/Data/List/OfFn.lean

tactic: cases n <;> simp only [ofFn_zero, ofFn_succ, eq_self_iff_true, Nat.succ_ne_zero]
state_before: α : Type u
n : ℕ
f : Fin n → α
⊢ ofFn f = [] ↔ n = 0
Theorem: IsCompact.disjoint_nhdsSet_right
File: Mathlib/Topology/SubsetProperties.lean

tactic: simpa only [disjoint_comm] using hs.disjoint_nhdsSet_left
state_before: α : Type u
β : Type v
ι : Type ?u.17404
π : ι → Type ?u.17409
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
l : Filter α
hs : IsCompact s
⊢ Disjoint l (𝓝ˢ s) ↔ ∀ (x : α), x ∈ s → Disjoint l (𝓝 x)
Theorem: Path.map_map
File: Mathlib/Topology/PathConnected.lean

tactic: ext
state_before: X : Type u_1
Y✝ : Type ?u.306794
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y✝
x y z : X
ι : Type ?u.306809
γ✝ γ : Path x y
Y : Type u_2
inst✝¹ : TopologicalSpace Y
Z : Type u_3
inst✝ : TopologicalSpace Z
f : X → Y
hf : Continuous f
g : Y → Z
hg : Continuous g
⊢ map (map γ hf) hg = map γ (_ : Continuous (g ∘ f))

tactic: rfl
state_before: case a.h
X : Type u_1
Y✝ : Type ?u.306794
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y✝
x y z : X
ι : Type ?u.306809
γ✝ γ : Path x y
Y : Type u_2
inst✝¹ : TopologicalSpace Y
Z : Type u_3
inst✝ : TopologicalSpace Z
f : X → Y
hf : Continuous f
g : Y → Z
hg : Continuous g
x✝ : ↑I
⊢ ↑(map (map γ hf) hg) x✝ = ↑(map γ (_ : Continuous (g ∘ f))) x✝
Theorem: PrimeSpectrum.preimage_comap_zeroLocus_aux
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: ext x
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
S' : Type ?u.109078
inst✝ : CommRing S'
f : R →+* S
s : Set R
⊢ (fun y => { asIdeal := Ideal.comap f y.asIdeal, IsPrime := (_ : Ideal.IsPrime (Ideal.comap f y.asIdeal)) }) ⁻¹'
      zeroLocus s =
    zeroLocus (↑f '' s)

tactic: simp only [mem_zeroLocus, Set.image_subset_iff]
state_before: case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
S' : Type ?u.109078
inst✝ : CommRing S'
f : R →+* S
s : Set R
x : PrimeSpectrum S
⊢ x ∈
      (fun y => { asIdeal := Ideal.comap f y.asIdeal, IsPrime := (_ : Ideal.IsPrime (Ideal.comap f y.asIdeal)) }) ⁻¹'
        zeroLocus s ↔
    x ∈ zeroLocus (↑f '' s)

tactic: rfl
state_before: case h
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
S' : Type ?u.109078
inst✝ : CommRing S'
f : R →+* S
s : Set R
x : PrimeSpectrum S
⊢ x ∈
      (fun y => { asIdeal := Ideal.comap f y.asIdeal, IsPrime := (_ : Ideal.IsPrime (Ideal.comap f y.asIdeal)) }) ⁻¹'
        zeroLocus s ↔
    s ⊆ (fun a => ↑f a) ⁻¹' ↑x.asIdeal
Theorem: AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono_id
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

tactic: unfold mapMono
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
⊢ mapMono K (𝟙 Δ) = 𝟙 (HomologicalComplex.X K (len Δ))

tactic: simp only [eq_self_iff_true, eqToHom_refl, dite_eq_ite, if_true]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ Δ' Δ'' : SimplexCategory
⊢ (if h : Δ = Δ then eqToHom (_ : HomologicalComplex.X K (len Δ) = HomologicalComplex.X K (len Δ))
    else if h : Isδ₀ (𝟙 Δ) then HomologicalComplex.d K (len Δ) (len Δ) else 0) =
    𝟙 (HomologicalComplex.X K (len Δ))
Theorem: Basis.coe_sumCoords_eq_finsum
File: Mathlib/LinearAlgebra/Basis.lean

tactic: ext m
state_before: ι : Type u_3
ι' : Type ?u.157559
R : Type u_1
R₂ : Type ?u.157565
K : Type ?u.157568
M : Type u_2
M' : Type ?u.157574
M'' : Type ?u.157577
V : Type u
V' : Type ?u.157582
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
⊢ ↑(sumCoords b) = fun m => ∑ᶠ (i : ι), ↑(coord b i) m

tactic: simp only [Basis.sumCoords, Basis.coord, Finsupp.lapply_apply, LinearMap.id_coe,
  LinearEquiv.coe_coe, Function.comp_apply, Finsupp.coe_lsum, LinearMap.coe_comp,
  finsum_eq_sum _ (b.repr m).finite_support, Finsupp.sum, Finset.finite_toSet_toFinset, id.def,
  Finsupp.fun_support_eq]
state_before: case h
ι : Type u_3
ι' : Type ?u.157559
R : Type u_1
R₂ : Type ?u.157565
K : Type ?u.157568
M : Type u_2
M' : Type ?u.157574
M'' : Type ?u.157577
V : Type u
V' : Type ?u.157582
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x m : M
⊢ ↑(sumCoords b) m = ∑ᶠ (i : ι), ↑(coord b i) m
Theorem: Asymptotics.SuperpolynomialDecay.mul_const
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simpa only [← mul_assoc, MulZeroClass.zero_mul] using Tendsto.mul_const c (hf z)
state_before: α : Type u_2
β : Type u_1
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : CommSemiring β
inst✝ : ContinuousMul β
hf : SuperpolynomialDecay l k f
c : β
z : ℕ
⊢ Tendsto (fun a => k a ^ z * (fun n => f n * c) a) l (𝓝 0)
Theorem: Zsqrtd.nonneg_smul
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: rw [← Int.cast_ofNat n]
state_before: d : ℕ
a : ℤ√↑d
n : ℕ
ha : Nonneg a
⊢ Nonneg (↑n * a)

tactic: exact
  match a, nonneg_cases ha, ha with
  | _, ⟨x, y, Or.inl rfl⟩, _ => by rw [smul_val]; trivial
  | _, ⟨x, y, Or.inr <| Or.inl rfl⟩, ha => by
    rw [smul_val]; simpa using nonnegg_pos_neg.2 (sqLe_smul n <| nonnegg_pos_neg.1 ha)
  | _, ⟨x, y, Or.inr <| Or.inr rfl⟩, ha => by
    rw [smul_val]; simpa using nonnegg_neg_pos.2 (sqLe_smul n <| nonnegg_neg_pos.1 ha)
state_before: d : ℕ
a : ℤ√↑d
n : ℕ
ha : Nonneg a
⊢ Nonneg (↑↑n * a)

tactic: rw [smul_val]
state_before: d : ℕ
a : ℤ√↑d
n : ℕ
ha : Nonneg a
x y : ℕ
x✝ : Nonneg { re := ↑x, im := ↑y }
⊢ Nonneg (↑↑n * { re := ↑x, im := ↑y })

tactic: trivial
state_before: d : ℕ
a : ℤ√↑d
n : ℕ
ha : Nonneg a
x y : ℕ
x✝ : Nonneg { re := ↑x, im := ↑y }
⊢ Nonneg { re := ↑n * ↑x, im := ↑n * ↑y }

tactic: rw [smul_val]
state_before: d : ℕ
a : ℤ√↑d
n : ℕ
ha✝ : Nonneg a
x y : ℕ
ha : Nonneg { re := ↑x, im := -↑y }
⊢ Nonneg (↑↑n * { re := ↑x, im := -↑y })

tactic: simpa using nonnegg_pos_neg.2 (sqLe_smul n <| nonnegg_pos_neg.1 ha)
state_before: d : ℕ
a : ℤ√↑d
n : ℕ
ha✝ : Nonneg a
x y : ℕ
ha : Nonneg { re := ↑x, im := -↑y }
⊢ Nonneg { re := ↑n * ↑x, im := ↑n * -↑y }

tactic: rw [smul_val]
state_before: d : ℕ
a : ℤ√↑d
n : ℕ
ha✝ : Nonneg a
x y : ℕ
ha : Nonneg { re := -↑x, im := ↑y }
⊢ Nonneg (↑↑n * { re := -↑x, im := ↑y })

tactic: simpa using nonnegg_neg_pos.2 (sqLe_smul n <| nonnegg_neg_pos.1 ha)
state_before: d : ℕ
a : ℤ√↑d
n : ℕ
ha✝ : Nonneg a
x y : ℕ
ha : Nonneg { re := -↑x, im := ↑y }
⊢ Nonneg { re := ↑n * -↑x, im := ↑n * ↑y }
Theorem: List.tfae_cons_of_mem
File: Mathlib/Data/List/TFAE.lean

tactic: simp
state_before: a b : Prop
l : List Prop
h : b ∈ l
H : TFAE (a :: l)
⊢ a ∈ a :: l

tactic: rintro ⟨ab, H⟩ p (_ | ⟨_, hp⟩) q (_ | ⟨_, hq⟩)
state_before: a b : Prop
l : List Prop
h : b ∈ l
⊢ (a ↔ b) ∧ TFAE l → TFAE (a :: l)

tactic: rfl
state_before: case intro.head.head
a b : Prop
l : List Prop
h : b ∈ l
ab : a ↔ b
H : TFAE l
⊢ a ↔ a

tactic: exact ab.trans (H _ h _ hq)
state_before: case intro.head.tail
a b : Prop
l : List Prop
h : b ∈ l
ab : a ↔ b
H : TFAE l
q : Prop
hq : Mem q l
⊢ a ↔ q

tactic: exact (ab.trans (H _ h _ hp)).symm
state_before: case intro.tail.head
a b : Prop
l : List Prop
h : b ∈ l
ab : a ↔ b
H : TFAE l
p : Prop
hp : Mem p l
⊢ p ↔ a

tactic: exact H _ hp _ hq
state_before: case intro.tail.tail
a b : Prop
l : List Prop
h : b ∈ l
ab : a ↔ b
H : TFAE l
p : Prop
hp : Mem p l
q : Prop
hq : Mem q l
⊢ p ↔ q
Theorem: LinearMap.le_rank_iff_exists_linearIndependent_finset
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: simp only [le_rank_iff_exists_linearIndependent, Cardinal.lift_natCast, Cardinal.lift_eq_nat_iff,
  Cardinal.mk_set_eq_nat_iff_finset]
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1195191
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
f : V →ₗ[K] V'
⊢ ↑n ≤ rank f ↔ ∃ s, Finset.card s = n ∧ LinearIndependent K fun x => ↑f ↑x

tactic: constructor
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1195191
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
f : V →ₗ[K] V'
⊢ (∃ s, (∃ t, ↑t = s ∧ Finset.card t = n) ∧ LinearIndependent K fun x => ↑f ↑x) ↔
    ∃ s, Finset.card s = n ∧ LinearIndependent K fun x => ↑f ↑x

tactic: rintro ⟨s, ⟨t, rfl, rfl⟩, si⟩
state_before: case mp
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1195191
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
f : V →ₗ[K] V'
⊢ (∃ s, (∃ t, ↑t = s ∧ Finset.card t = n) ∧ LinearIndependent K fun x => ↑f ↑x) →
    ∃ s, Finset.card s = n ∧ LinearIndependent K fun x => ↑f ↑x

tactic: exact ⟨t, rfl, si⟩
state_before: case mp.intro.intro.intro.intro
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1195191
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
f : V →ₗ[K] V'
t : Finset V
si : LinearIndependent K fun x => ↑f ↑x
⊢ ∃ s, Finset.card s = Finset.card t ∧ LinearIndependent K fun x => ↑f ↑x

tactic: rintro ⟨s, rfl, si⟩
state_before: case mpr
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1195191
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
f : V →ₗ[K] V'
⊢ (∃ s, Finset.card s = n ∧ LinearIndependent K fun x => ↑f ↑x) →
    ∃ s, (∃ t, ↑t = s ∧ Finset.card t = n) ∧ LinearIndependent K fun x => ↑f ↑x

tactic: exact ⟨s, ⟨s, rfl, rfl⟩, si⟩
state_before: case mpr.intro.intro
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1195191
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
f : V →ₗ[K] V'
s : Finset V
si : LinearIndependent K fun x => ↑f ↑x
⊢ ∃ s_1, (∃ t, ↑t = s_1 ∧ Finset.card t = Finset.card s) ∧ LinearIndependent K fun x => ↑f ↑x
Theorem: Turing.TM2to1.trStmts₁_run
File: Mathlib/Computability/TuringMachine.lean

tactic: cases s <;> simp only [trStmts₁]
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_4
inst✝¹ : Inhabited Λ
σ : Type u_3
inst✝ : Inhabited σ
k : K
s : StAct k
q : Stmt₂
⊢ trStmts₁ (stRun s q) = {go k s q, ret q} ∪ trStmts₁ q
Theorem: Submodule.comap_smul
File: Mathlib/LinearAlgebra/Basic.lean

tactic: ext b
state_before: R : Type ?u.955175
R₁ : Type ?u.955178
R₂ : Type ?u.955181
R₃ : Type ?u.955184
R₄ : Type ?u.955187
S : Type ?u.955190
K : Type u_1
K₂ : Type ?u.955196
M : Type ?u.955199
M' : Type ?u.955202
M₁ : Type ?u.955205
M₂ : Type ?u.955208
M₃ : Type ?u.955211
M₄ : Type ?u.955214
N : Type ?u.955217
N₂ : Type ?u.955220
ι : Type ?u.955223
V : Type u_2
V₂ : Type u_3
inst✝⁴ : Semifield K
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
p : Submodule K V₂
a : K
h : a ≠ 0
⊢ comap (a • f) p = comap f p

tactic: simp only [Submodule.mem_comap, p.smul_mem_iff h, LinearMap.smul_apply]
state_before: case h
R : Type ?u.955175
R₁ : Type ?u.955178
R₂ : Type ?u.955181
R₃ : Type ?u.955184
R₄ : Type ?u.955187
S : Type ?u.955190
K : Type u_1
K₂ : Type ?u.955196
M : Type ?u.955199
M' : Type ?u.955202
M₁ : Type ?u.955205
M₂ : Type ?u.955208
M₃ : Type ?u.955211
M₄ : Type ?u.955214
N : Type ?u.955217
N₂ : Type ?u.955220
ι : Type ?u.955223
V : Type u_2
V₂ : Type u_3
inst✝⁴ : Semifield K
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
p : Submodule K V₂
a : K
h : a ≠ 0
b : V
⊢ b ∈ comap (a • f) p ↔ b ∈ comap f p
Theorem: bind_congr
File: src/lean/Init/Control/Lawful.lean

tactic: simp [funext h]
state_before: m : Type u_1 → Type u_2
α β : Type u_1
inst✝ : Bind m
x : m α
f g : α → m β
h : ∀ (a : α), f a = g a
⊢ x >>= f = x >>= g
Theorem: Ideal.IsMaximal.coprime_of_ne
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: contrapose! hne with h
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
M M' : Ideal α
hM : IsMaximal M
hM' : IsMaximal M'
hne : M ≠ M'
⊢ M ⊔ M' = ⊤

tactic: exact hM.eq_of_le hM'.ne_top (le_sup_left.trans_eq (hM'.eq_of_le h le_sup_right).symm)
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
M M' : Ideal α
hM : IsMaximal M
hM' : IsMaximal M'
h : M ⊔ M' ≠ ⊤
⊢ M = M'
Theorem: MeasureTheory.integral_eq_of_has_deriv_within_at_off_countable
File: Mathlib/MeasureTheory/Integral/DivergenceTheorem.lean

tactic: cases' le_total a b with hab hab
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f f' : ℝ → E
a b : ℝ
s : Set ℝ
hs : Set.Countable s
Hc : ContinuousOn f [[a, b]]
Hd : ∀ (x : ℝ), x ∈ Set.Ioo (min a b) (max a b) \ s → HasDerivAt f (f' x) x
Hi : IntervalIntegrable f' volume a b
⊢ (∫ (x : ℝ) in a..b, f' x) = f b - f a

tactic: simp only [uIcc_of_le hab, min_eq_left hab, max_eq_right hab] at *
state_before: case inl
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f f' : ℝ → E
a b : ℝ
s : Set ℝ
hs : Set.Countable s
Hc : ContinuousOn f [[a, b]]
Hd : ∀ (x : ℝ), x ∈ Set.Ioo (min a b) (max a b) \ s → HasDerivAt f (f' x) x
Hi : IntervalIntegrable f' volume a b
hab : a ≤ b
⊢ (∫ (x : ℝ) in a..b, f' x) = f b - f a

tactic: exact integral_eq_of_hasDerivWithinAt_off_countable_of_le f f' hab hs Hc Hd Hi
state_before: case inl
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f f' : ℝ → E
a b : ℝ
s : Set ℝ
hs : Set.Countable s
Hi : IntervalIntegrable f' volume a b
hab : a ≤ b
Hc : ContinuousOn f (Set.Icc a b)
Hd : ∀ (x : ℝ), x ∈ Set.Ioo a b \ s → HasDerivAt f (f' x) x
⊢ (∫ (x : ℝ) in a..b, f' x) = f b - f a

tactic: simp only [uIcc_of_ge hab, min_eq_right hab, max_eq_left hab] at *
state_before: case inr
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f f' : ℝ → E
a b : ℝ
s : Set ℝ
hs : Set.Countable s
Hc : ContinuousOn f [[a, b]]
Hd : ∀ (x : ℝ), x ∈ Set.Ioo (min a b) (max a b) \ s → HasDerivAt f (f' x) x
Hi : IntervalIntegrable f' volume a b
hab : b ≤ a
⊢ (∫ (x : ℝ) in a..b, f' x) = f b - f a

tactic: rw [intervalIntegral.integral_symm, neg_eq_iff_eq_neg, neg_sub]
state_before: case inr
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f f' : ℝ → E
a b : ℝ
s : Set ℝ
hs : Set.Countable s
Hi : IntervalIntegrable f' volume a b
hab : b ≤ a
Hc : ContinuousOn f (Set.Icc b a)
Hd : ∀ (x : ℝ), x ∈ Set.Ioo b a \ s → HasDerivAt f (f' x) x
⊢ (∫ (x : ℝ) in a..b, f' x) = f b - f a

tactic: exact integral_eq_of_hasDerivWithinAt_off_countable_of_le f f' hab hs Hc Hd Hi.symm
state_before: case inr
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f f' : ℝ → E
a b : ℝ
s : Set ℝ
hs : Set.Countable s
Hi : IntervalIntegrable f' volume a b
hab : b ≤ a
Hc : ContinuousOn f (Set.Icc b a)
Hd : ∀ (x : ℝ), x ∈ Set.Ioo b a \ s → HasDerivAt f (f' x) x
⊢ (∫ (x : ℝ) in b..a, f' x) = f a - f b
Theorem: Convex.subset_toCone
File: Mathlib/Analysis/Convex/Cone/Basic.lean

tactic: rwa [one_smul]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.172872
G : Type ?u.172875
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
hs : Convex 𝕜 s
x✝ x : E
hx : x ∈ s
⊢ 1 • x ∈ s
Theorem: Filter.mem_prod_principal
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [← @exists_mem_subset_iff _ f, mem_prod_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2996
δ : Type ?u.2999
ι : Sort ?u.3002
s✝ : Set α
t✝ : Set β
f✝ : Filter α
g : Filter β
f : Filter α
s : Set (α × β)
t : Set β
⊢ s ∈ f ×ˢ 𝓟 t ↔ {a | ∀ (b : β), b ∈ t → (a, b) ∈ s} ∈ f

tactic: refine' exists_congr fun u => Iff.rfl.and ⟨_, fun h => ⟨t, mem_principal_self t, _⟩⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2996
δ : Type ?u.2999
ι : Sort ?u.3002
s✝ : Set α
t✝ : Set β
f✝ : Filter α
g : Filter β
f : Filter α
s : Set (α × β)
t : Set β
⊢ (∃ t₁, t₁ ∈ f ∧ ∃ t₂, t₂ ∈ 𝓟 t ∧ t₁ ×ˢ t₂ ⊆ s) ↔ ∃ t_1, t_1 ∈ f ∧ t_1 ⊆ {a | ∀ (b : β), b ∈ t → (a, b) ∈ s}

tactic: rintro ⟨v, v_in, hv⟩ a a_in b b_in
state_before: case refine'_1
α : Type u_1
β : Type u_2
γ : Type ?u.2996
δ : Type ?u.2999
ι : Sort ?u.3002
s✝ : Set α
t✝ : Set β
f✝ : Filter α
g : Filter β
f : Filter α
s : Set (α × β)
t : Set β
u : Set α
⊢ (∃ t₂, t₂ ∈ 𝓟 t ∧ u ×ˢ t₂ ⊆ s) → u ⊆ {a | ∀ (b : β), b ∈ t → (a, b) ∈ s}

tactic: exact hv (mk_mem_prod a_in <| v_in b_in)
state_before: case refine'_1.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.2996
δ : Type ?u.2999
ι : Sort ?u.3002
s✝ : Set α
t✝ : Set β
f✝ : Filter α
g : Filter β
f : Filter α
s : Set (α × β)
t : Set β
u : Set α
v : Set β
v_in : v ∈ 𝓟 t
hv : u ×ˢ v ⊆ s
a : α
a_in : a ∈ u
b : β
b_in : b ∈ t
⊢ (a, b) ∈ s

tactic: rintro ⟨x, y⟩ ⟨hx, hy⟩
state_before: case refine'_2
α : Type u_1
β : Type u_2
γ : Type ?u.2996
δ : Type ?u.2999
ι : Sort ?u.3002
s✝ : Set α
t✝ : Set β
f✝ : Filter α
g : Filter β
f : Filter α
s : Set (α × β)
t : Set β
u : Set α
h : u ⊆ {a | ∀ (b : β), b ∈ t → (a, b) ∈ s}
⊢ u ×ˢ t ⊆ s

tactic: exact h hx y hy
state_before: case refine'_2.mk.intro
α : Type u_1
β : Type u_2
γ : Type ?u.2996
δ : Type ?u.2999
ι : Sort ?u.3002
s✝ : Set α
t✝ : Set β
f✝ : Filter α
g : Filter β
f : Filter α
s : Set (α × β)
t : Set β
u : Set α
h : u ⊆ {a | ∀ (b : β), b ∈ t → (a, b) ∈ s}
x : α
y : β
hx : (x, y).fst ∈ u
hy : (x, y).snd ∈ t
⊢ (x, y) ∈ s