tasksource/leandojo huggingface dataset:
Theorem: ContinuousMap.isUnit_iff_forall_isUnit
File: Mathlib/Topology/ContinuousFunction/Units.lean

tactic: ext
state_before: X : Type u_1
M : Type ?u.390661
R : Type u_2
𝕜 : Type ?u.390667
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (↑f x)
⊢ ↑(↑unitsLift (unitsOfForallIsUnit h)) = f

tactic: rfl
state_before: case h
X : Type u_1
M : Type ?u.390661
R : Type u_2
𝕜 : Type ?u.390667
inst✝² : TopologicalSpace X
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f : C(X, R)
h : ∀ (x : X), IsUnit (↑f x)
a✝ : X
⊢ ↑↑(↑unitsLift (unitsOfForallIsUnit h)) a✝ = ↑f a✝
Theorem: Submodule.prodEquivOfIsCompl_symm_apply_snd_eq_zero
File: Mathlib/LinearAlgebra/Projection.lean

tactic: conv_rhs => rw [← (prodEquivOfIsCompl p q h).apply_symm_apply x]
state_before: R : Type u_2
inst✝⁹ : Ring R
E : Type u_1
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.109042
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.109558
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.110521
inst✝² : Semiring S
M : Type ?u.110527
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
x : E
⊢ (↑(LinearEquiv.symm (prodEquivOfIsCompl p q h)) x).snd = 0 ↔ x ∈ p

tactic: rw [coe_prodEquivOfIsCompl', Submodule.add_mem_iff_right _ (Submodule.coe_mem _),
  mem_left_iff_eq_zero_of_disjoint h.disjoint]
state_before: R : Type u_2
inst✝⁹ : Ring R
E : Type u_1
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.109042
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.109558
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.110521
inst✝² : Semiring S
M : Type ?u.110527
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
x : E
⊢ (↑(LinearEquiv.symm (prodEquivOfIsCompl p q h)) x).snd = 0 ↔
    ↑(prodEquivOfIsCompl p q h) (↑(LinearEquiv.symm (prodEquivOfIsCompl p q h)) x) ∈ p
Theorem: Polynomial.coeff_add_eq_right_of_lt
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: rw [add_comm]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
pn : natDegree p < n
⊢ coeff (p + q) n = coeff q n

tactic: exact coeff_add_eq_left_of_lt pn
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
pn : natDegree p < n
⊢ coeff (q + p) n = coeff q n
Theorem: Nat.card_eq_of_equiv_fin
File: Mathlib/SetTheory/Cardinal/Finite.lean

tactic: simpa only [card_eq_fintype_card, Fintype.card_fin] using card_congr f
state_before: α✝ : Type ?u.8654
β : Type ?u.8657
α : Type u_1
n : ℕ
f : α ≃ Fin n
⊢ Nat.card α = n
Theorem: Submodule.le_div_iff_mul_le
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rw [le_div_iff, mul_le]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M N : Submodule R A
m n : A
I J K : Submodule R A
⊢ I ≤ J / K ↔ I * K ≤ J
Theorem: MonoidHom.restrict_mrange
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: simp [SetLike.ext_iff]
state_before: M : Type u_1
N : Type u_2
P : Type ?u.123584
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.123605
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type ?u.123629
mc : MonoidHomClass F M N
f : M →* N
⊢ mrange (restrict f S) = map f S
Theorem: PowerSeries.coeff_cos_bit1
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: rw [cos, coeff_mk, if_neg n.not_even_bit1]
state_before: A : Type u_1
A' : Type ?u.382438
inst✝⁷ : Ring A
inst✝⁶ : Ring A'
inst✝⁵ : Algebra ℚ A
inst✝⁴ : Algebra ℚ A'
inst✝³ : Ring A
inst✝² : Ring A'
inst✝¹ : Algebra ℚ A
inst✝ : Algebra ℚ A'
n : ℕ
f : A →+* A'
⊢ ↑(coeff A (bit1 n)) (cos A) = 0
Theorem: PowerBasis.quotientEquivQuotientMinpolyMap_symm_apply_mk
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: simp only [quotientEquivQuotientMinpolyMap, toRingEquiv_eq_coe, symm_trans_apply,
  quotEquivQuotMap_symm_apply_mk, ofRingEquiv_symm_apply, quotientEquiv_symm_mk,
  toRingEquiv_symm, RingEquiv.symm_symm, AdjoinRoot.equiv'_apply, coe_ringEquiv, liftHom_mk,
  symm_toRingEquiv]
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
pb : PowerBasis R S
I : Ideal R
g : R[X]
⊢ ↑(AlgEquiv.symm (quotientEquivQuotientMinpolyMap pb I))
      (↑(Ideal.Quotient.mk (span {Polynomial.map (Ideal.Quotient.mk I) (minpoly R pb.gen)}))
        (Polynomial.map (Ideal.Quotient.mk I) g)) =
    ↑(Ideal.Quotient.mk (Ideal.map (algebraMap R S) I)) (↑(aeval pb.gen) g)
Theorem: ContinuousMap.nhds_compactOpen_eq_sInf_nhds_induced
File: Mathlib/Topology/CompactOpen.lean

tactic: rw [compactOpen_eq_sInf_induced]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.23663
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : C(α, β)
⊢ 𝓝 f = ⨅ (s : Set α) (_ : IsCompact s), Filter.comap (restrict s) (𝓝 (restrict s f))

tactic: simp [nhds_iInf, nhds_induced]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.23663
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : C(α, β)
⊢ 𝓝 f = ⨅ (s : Set α) (_ : IsCompact s), Filter.comap (restrict s) (𝓝 (restrict s f))
Theorem: Bool.forall_bool
File: Mathlib/Data/Bool/Basic.lean

tactic: simp [h]
state_before: p : Bool → Prop
h : ∀ (b : Bool), p b
⊢ p false ∧ p true

tactic: cases b <;> assumption
state_before: p : Bool → Prop
x✝ : p false ∧ p true
b : Bool
h₁ : p false
h₂ : p true
⊢ p b
Theorem: Finsupp.card_Ioo
File: Mathlib/Data/Finsupp/Interval.lean

tactic: rw [card_Ioo_eq_card_Icc_sub_two, card_Icc]
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : Zero α
inst✝ : LocallyFiniteOrder α
f g : ι →₀ α
⊢ card (Ioo f g) = ∏ i in f.support ∪ g.support, card (Icc (↑f i) (↑g i)) - 2
Theorem: MeasureTheory.average_zero_measure
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: rw [average, smul_zero, integral_zero_measure]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.180121
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ : Measure α
s : Set E
f : α → E
⊢ (⨍ (x : α), f x ∂0) = 0
Theorem: Set.image2_def
File: Mathlib/Data/Set/Functor.lean

tactic: ext
state_before: α✝ β✝ : Type u
s✝ : Set α✝
f✝ : α✝ → Set β✝
g : Set (α✝ → β✝)
α β γ : Type u_1
f : α → β → γ
s : Set α
t : Set β
⊢ image2 f s t = Seq.seq (f <$> s) fun x => t

tactic: simp
state_before: case h
α✝ β✝ : Type u
s✝ : Set α✝
f✝ : α✝ → Set β✝
g : Set (α✝ → β✝)
α β γ : Type u_1
f : α → β → γ
s : Set α
t : Set β
x✝ : γ
⊢ x✝ ∈ image2 f s t ↔ x✝ ∈ Seq.seq (f <$> s) fun x => t
Theorem: InitialSeg.init_iff
File: Mathlib/Order/InitialSeg.lean

tactic: rcases f.init h with ⟨a', rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.12477
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : r ≼i s
a : α
b : β
h : s b (↑f a)
⊢ ∃ a', ↑f a' = b ∧ r a' a

tactic: exact ⟨a', rfl, f.map_rel_iff.1 h⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.12477
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : r ≼i s
a a' : α
h : s (↑f a') (↑f a)
⊢ ∃ a'_1, ↑f a'_1 = ↑f a' ∧ r a'_1 a
Theorem: Multiset.rel_replicate_left
File: Mathlib/Data/Multiset/Basic.lean

tactic: obtain ⟨b, hb1, hb2⟩ := exists_mem_of_rel_of_mem (rel_flip.2 h) hx
state_before: α : Type u_1
β : Type ?u.474373
γ : Type ?u.474376
δ : Type ?u.474379
r✝ : α → β → Prop
p : γ → δ → Prop
m : Multiset α
a : α
r : α → α → Prop
n : ℕ
h : Rel r (replicate n a) m
x : α
hx : x ∈ m
⊢ r a x

tactic: rwa [eq_of_mem_replicate hb1] at hb2
state_before: case intro.intro
α : Type u_1
β : Type ?u.474373
γ : Type ?u.474376
δ : Type ?u.474379
r✝ : α → β → Prop
p : γ → δ → Prop
m : Multiset α
a : α
r : α → α → Prop
n : ℕ
h : Rel r (replicate n a) m
x : α
hx : x ∈ m
b : α
hb1 : b ∈ replicate n a
hb2 : flip r x b
⊢ r a x
Theorem: Filter.mem_prod_iff
File: Mathlib/Order/Filter/Prod.lean

tactic: simp only [SProd.sprod, Filter.prod]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.1020
δ : Type ?u.1023
ι : Sort ?u.1026
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
s : Set (α × β)
f : Filter α
g : Filter β
⊢ s ∈ f ×ˢ g ↔ ∃ t₁, t₁ ∈ f ∧ ∃ t₂, t₂ ∈ g ∧ t₁ ×ˢ t₂ ⊆ s

tactic: constructor
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.1020
δ : Type ?u.1023
ι : Sort ?u.1026
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
s : Set (α × β)
f : Filter α
g : Filter β
⊢ s ∈ comap Prod.fst f ⊓ comap Prod.snd g ↔ ∃ t₁, t₁ ∈ f ∧ ∃ t₂, t₂ ∈ g ∧ prod t₁ t₂ ⊆ s

tactic: rintro ⟨t₁, ⟨s₁, hs₁, hts₁⟩, t₂, ⟨s₂, hs₂, hts₂⟩, rfl⟩
state_before: case mp
α : Type u_2
β : Type u_1
γ : Type ?u.1020
δ : Type ?u.1023
ι : Sort ?u.1026
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
s : Set (α × β)
f : Filter α
g : Filter β
⊢ s ∈ comap Prod.fst f ⊓ comap Prod.snd g → ∃ t₁, t₁ ∈ f ∧ ∃ t₂, t₂ ∈ g ∧ prod t₁ t₂ ⊆ s

tactic: exact ⟨s₁, hs₁, s₂, hs₂, fun p ⟨h, h'⟩ => ⟨hts₁ h, hts₂ h'⟩⟩
state_before: case mp.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_2
β : Type u_1
γ : Type ?u.1020
δ : Type ?u.1023
ι : Sort ?u.1026
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
t₁ : Set (α × β)
s₁ : Set α
hs₁ : s₁ ∈ f
hts₁ : Prod.fst ⁻¹' s₁ ⊆ t₁
t₂ : Set (α × β)
s₂ : Set β
hs₂ : s₂ ∈ g
hts₂ : Prod.snd ⁻¹' s₂ ⊆ t₂
⊢ ∃ t₁_1, t₁_1 ∈ f ∧ ∃ t₂_1, t₂_1 ∈ g ∧ prod t₁_1 t₂_1 ⊆ t₁ ∩ t₂

tactic: rintro ⟨t₁, ht₁, t₂, ht₂, h⟩
state_before: case mpr
α : Type u_2
β : Type u_1
γ : Type ?u.1020
δ : Type ?u.1023
ι : Sort ?u.1026
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
s : Set (α × β)
f : Filter α
g : Filter β
⊢ (∃ t₁, t₁ ∈ f ∧ ∃ t₂, t₂ ∈ g ∧ prod t₁ t₂ ⊆ s) → s ∈ comap Prod.fst f ⊓ comap Prod.snd g

tactic: exact mem_inf_of_inter (preimage_mem_comap ht₁) (preimage_mem_comap ht₂) h
state_before: case mpr.intro.intro.intro.intro
α : Type u_2
β : Type u_1
γ : Type ?u.1020
δ : Type ?u.1023
ι : Sort ?u.1026
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
s : Set (α × β)
f : Filter α
g : Filter β
t₁ : Set α
ht₁ : t₁ ∈ f
t₂ : Set β
ht₂ : t₂ ∈ g
h : prod t₁ t₂ ⊆ s
⊢ s ∈ comap Prod.fst f ⊓ comap Prod.snd g
Theorem: differentiableOn_const_sub_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simp [sub_eq_add_neg]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.561985
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.562080
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
⊢ DifferentiableOn 𝕜 (fun y => c - f y) s ↔ DifferentiableOn 𝕜 f s
Theorem: BoxIntegral.HasIntegral.congr_ae
File: Mathlib/Analysis/BoxIntegral/Integrability.lean

tactic: have : g - f =ᵐ[μ.restrict I] 0 := hfg.mono fun x hx => sub_eq_zero.2 hx.symm
state_before: ι : Type u
E : Type v
inst✝³ : Fintype ι
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
l : IntegrationParams
I : Box ι
y : E
f g : (ι → ℝ) → E
μ : MeasureTheory.Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
hf : HasIntegral I l f (BoxAdditiveMap.toSMul (Measure.toBoxAdditive μ)) y
hfg : f =ᵐ[Measure.restrict μ ↑I] g
hl : l.bRiemann = false
⊢ HasIntegral I l g (BoxAdditiveMap.toSMul (Measure.toBoxAdditive μ)) y

tactic: simpa using hf.add (HasIntegral.of_aeEq_zero this hl)
state_before: ι : Type u
E : Type v
inst✝³ : Fintype ι
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
l : IntegrationParams
I : Box ι
y : E
f g : (ι → ℝ) → E
μ : MeasureTheory.Measure (ι → ℝ)
inst✝ : IsLocallyFiniteMeasure μ
hf : HasIntegral I l f (BoxAdditiveMap.toSMul (Measure.toBoxAdditive μ)) y
hfg : f =ᵐ[Measure.restrict μ ↑I] g
hl : l.bRiemann = false
this : g - f =ᵐ[Measure.restrict μ ↑I] 0
⊢ HasIntegral I l g (BoxAdditiveMap.toSMul (Measure.toBoxAdditive μ)) y
Theorem: Dfinsupp.mk_zero
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp only [mk_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
i : ι
⊢ ↑(mk s 0) i = ↑0 i

tactic: split_ifs <;> rfl
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → Zero (β i)
s : Finset ι
i : ι
⊢ (if H : i ∈ s then OfNat.ofNat 0 { val := i, property := H } else 0) = ↑0 i
Theorem: Associates.mk_pow
File: Mathlib/Algebra/Associated.lean

tactic: induction n <;> simp [*, pow_succ, Associates.mk_mul_mk.symm]
state_before: α : Type u_1
β : Type ?u.277786
γ : Type ?u.277789
δ : Type ?u.277792
inst✝ : CommMonoid α
a : α
n : ℕ
⊢ Associates.mk (a ^ n) = Associates.mk a ^ n
Theorem: List.asString_inj
File: Mathlib/Data/String/Basic.lean

tactic: rw [← toList_inv_asString l, ← toList_inv_asString l', toList_inj, h]
state_before: l l' : List Char
h : asString l = asString l'
⊢ l = l'
Theorem: LowerSet.compl_iInf
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp only [coe_compl, coe_iInf, compl_iInter, UpperSet.coe_iInf]
state_before: α : Type u_1
β : Type ?u.89932
γ : Type ?u.89935
ι : Sort u_2
κ : ι → Sort ?u.89943
inst✝ : LE α
s t : LowerSet α
a : α
f : ι → LowerSet α
⊢ ↑(compl (⨅ (i : ι), f i)) = ↑(⨅ (i : ι), compl (f i))
Theorem: Matrix.sub_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [sub_eq_add_neg]
state_before: l : Type ?u.178976
m : Type u_1
n : Type ?u.178982
o : Type ?u.178985
m' : o → Type ?u.178990
n' : o → Type ?u.178995
R : Type ?u.178998
S : Type ?u.179001
α : Type v
β : Type w
γ : Type ?u.179008
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocRing α
u v w : m → α
⊢ (u - v) ⬝ᵥ w = u ⬝ᵥ w - v ⬝ᵥ w
Theorem: ZFSet.mem_sInter
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: rw [sInter, dif_pos h]
state_before: x y : ZFSet
h : ZFSet.Nonempty x
⊢ y ∈ ⋂₀ x ↔ ∀ (z : ZFSet), z ∈ x → y ∈ z

tactic: simp only [mem_toSet, mem_sep, and_iff_right_iff_imp]
state_before: x y : ZFSet
h : ZFSet.Nonempty x
⊢ y ∈ ZFSet.sep (fun y => ∀ (z : ZFSet), z ∈ x → y ∈ z) (Set.Nonempty.some h) ↔ ∀ (z : ZFSet), z ∈ x → y ∈ z

tactic: exact fun H => H _ h.some_mem
state_before: x y : ZFSet
h : ZFSet.Nonempty x
⊢ (∀ (z : ZFSet), z ∈ x → y ∈ z) → y ∈ Set.Nonempty.some h
Theorem: FreeProduct.NeWord.inv_last
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: induction w <;> simp [inv, *]
state_before: ι : Type u_1
M : ι → Type ?u.651212
inst✝² : (i : ι) → Monoid (M i)
N : Type ?u.651223
inst✝¹ : Monoid N
G : ι → Type u_2
inst✝ : (i : ι) → Group (G i)
i j : ι
w : NeWord G i j
⊢ last (inv w) = (head w)⁻¹
Theorem: List.not_nodup_of_get_eq_of_ne
File: Mathlib/Data/List/Nodup.lean

tactic: rw [nodup_iff_injective_get]
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
xs : List α
n m : Fin (length xs)
h : get xs n = get xs m
hne : n ≠ m
⊢ ¬Nodup xs

tactic: exact fun hinj => hne (hinj h)
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
xs : List α
n m : Fin (length xs)
h : get xs n = get xs m
hne : n ≠ m
⊢ ¬Injective (get xs)
Theorem: IsCompact.inter_iInter_nonempty
File: Mathlib/Topology/SubsetProperties.lean

tactic: simp only [nonempty_iff_ne_empty] at hsZ⊢
state_before: α : Type u
β : Type v
ι✝ : Type ?u.20882
π : ι✝ → Type ?u.20887
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t s : Set α
ι : Type v
hs : IsCompact s
Z : ι → Set α
hZc : ∀ (i : ι), IsClosed (Z i)
hsZ : ∀ (t : Finset ι), Set.Nonempty (s ∩ ⋂ (i : ι) (_ : i ∈ t), Z i)
⊢ Set.Nonempty (s ∩ ⋂ (i : ι), Z i)

tactic: apply mt (hs.elim_finite_subfamily_closed Z hZc)
state_before: α : Type u
β : Type v
ι✝ : Type ?u.20882
π : ι✝ → Type ?u.20887
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t s : Set α
ι : Type v
hs : IsCompact s
Z : ι → Set α
hZc : ∀ (i : ι), IsClosed (Z i)
hsZ : ∀ (t : Finset ι), (s ∩ ⋂ (i : ι) (_ : i ∈ t), Z i) ≠ ∅
⊢ (s ∩ ⋂ (i : ι), Z i) ≠ ∅

tactic: push_neg
state_before: α : Type u
β : Type v
ι✝ : Type ?u.20882
π : ι✝ → Type ?u.20887
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t s : Set α
ι : Type v
hs : IsCompact s
Z : ι → Set α
hZc : ∀ (i : ι), IsClosed (Z i)
hsZ : ∀ (t : Finset ι), (s ∩ ⋂ (i : ι) (_ : i ∈ t), Z i) ≠ ∅
⊢ ¬∃ t, (s ∩ ⋂ (i : ι) (_ : i ∈ t), Z i) = ∅

tactic: exact hsZ
state_before: α : Type u
β : Type v
ι✝ : Type ?u.20882
π : ι✝ → Type ?u.20887
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t s : Set α
ι : Type v
hs : IsCompact s
Z : ι → Set α
hZc : ∀ (i : ι), IsClosed (Z i)
hsZ : ∀ (t : Finset ι), (s ∩ ⋂ (i : ι) (_ : i ∈ t), Z i) ≠ ∅
⊢ ∀ (t : Finset ι), (s ∩ ⋂ (i : ι) (_ : i ∈ t), Z i) ≠ ∅
Theorem: Complex.im_eq_sub_conj
File: Mathlib/Data/Complex/Basic.lean

tactic: have : (↑2 : ℝ ) * I = 2 * I := by rfl
state_before: z : ℂ
⊢ ↑z.im = (z - ↑(starRingEnd ℂ) z) / (2 * I)

tactic: simp only [sub_conj, ofReal_mul, ofReal_one, ofReal_bit0, mul_right_comm, this,
  mul_div_cancel_left _ (mul_ne_zero two_ne_zero I_ne_zero : 2 * I ≠ 0)]
state_before: z : ℂ
this : ↑2 * I = 2 * I
⊢ ↑z.im = (z - ↑(starRingEnd ℂ) z) / (2 * I)

tactic: rfl
state_before: z : ℂ
⊢ ↑2 * I = 2 * I
Theorem: FreeProduct.lift_mrange_le
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: rintro _ ⟨x, rfl⟩
state_before: ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.252280
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
f : (i : ι) → M i →* N
s : Submonoid N
h : ∀ (i : ι), MonoidHom.mrange (f i) ≤ s
⊢ MonoidHom.mrange (↑lift f) ≤ s

tactic: induction' x using FreeProduct.induction_on with i x x y hx hy
state_before: case intro
ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.252280
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
f : (i : ι) → M i →* N
s : Submonoid N
h : ∀ (i : ι), MonoidHom.mrange (f i) ≤ s
x : FreeProduct fun i => M i
⊢ ↑(↑lift f) x ∈ s

tactic: exact s.one_mem
state_before: case intro.h_one
ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.252280
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
f : (i : ι) → M i →* N
s : Submonoid N
h : ∀ (i : ι), MonoidHom.mrange (f i) ≤ s
⊢ ↑(↑lift f) 1 ∈ s

tactic: simp only [lift_of, SetLike.mem_coe]
state_before: case intro.h_of
ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.252280
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
f : (i : ι) → M i →* N
s : Submonoid N
h : ∀ (i : ι), MonoidHom.mrange (f i) ≤ s
i : ι
x : M i
⊢ ↑(↑lift f) (↑of x) ∈ s

tactic: exact h i (Set.mem_range_self x)
state_before: case intro.h_of
ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.252280
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
f : (i : ι) → M i →* N
s : Submonoid N
h : ∀ (i : ι), MonoidHom.mrange (f i) ≤ s
i : ι
x : M i
⊢ ↑(f i) x ∈ s

tactic: simp only [map_mul, SetLike.mem_coe]
state_before: case intro.h_mul
ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.252280
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
f : (i : ι) → M i →* N
s : Submonoid N
h : ∀ (i : ι), MonoidHom.mrange (f i) ≤ s
x y : FreeProduct fun i => M i
hx : ↑(↑lift f) x ∈ s
hy : ↑(↑lift f) y ∈ s
⊢ ↑(↑lift f) (x * y) ∈ s

tactic: exact s.mul_mem hx hy
state_before: case intro.h_mul
ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.252280
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
f : (i : ι) → M i →* N
s : Submonoid N
h : ∀ (i : ι), MonoidHom.mrange (f i) ≤ s
x y : FreeProduct fun i => M i
hx : ↑(↑lift f) x ∈ s
hy : ↑(↑lift f) y ∈ s
⊢ ↑(↑lift f) x * ↑(↑lift f) y ∈ s
Theorem: FirstOrder.Language.card_mk₂
File: Mathlib/ModelTheory/Basic.lean

tactic: simp [card_eq_card_functions_add_card_relations, add_assoc]
state_before: L : Language
L' : Language
c f₁ f₂ : Type u
r₁ r₂ : Type v
⊢ card (Language.mk₂ c f₁ f₂ r₁ r₂) = lift (#c) + lift (#f₁) + lift (#f₂) + lift (#r₁) + lift (#r₂)
Theorem: homology.map_id
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: ext
state_before: ι : Type ?u.123641
V : Type u
inst✝¹⁹ : Category V
inst✝¹⁸ : HasZeroMorphisms V
A B C : V
f : A ⟶ B
inst✝¹⁷ : HasImage f
g : B ⟶ C
inst✝¹⁶ : HasKernel g
w : f ≫ g = 0
A' B' C' : V
f' : A' ⟶ B'
inst✝¹⁵ : HasImage f'
g' : B' ⟶ C'
inst✝¹⁴ : HasKernel g'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
inst✝¹³ : HasImageMap α
β : Arrow.mk g ⟶ Arrow.mk g'
A₁ B₁ C₁ : V
f₁ : A₁ ⟶ B₁
inst✝¹² : HasImage f₁
g₁ : B₁ ⟶ C₁
inst✝¹¹ : HasKernel g₁
w₁ : f₁ ≫ g₁ = 0
A₂ B₂ C₂ : V
f₂ : A₂ ⟶ B₂
inst✝¹⁰ : HasImage f₂
g₂ : B₂ ⟶ C₂
inst✝⁹ : HasKernel g₂
w₂ : f₂ ≫ g₂ = 0
A₃ B₃ C₃ : V
f₃ : A₃ ⟶ B₃
inst✝⁸ : HasImage f₃
g₃ : B₃ ⟶ C₃
inst✝⁷ : HasKernel g₃
w₃ : f₃ ≫ g₃ = 0
α₁ : Arrow.mk f₁ ⟶ Arrow.mk f₂
inst✝⁶ : HasImageMap α₁
β₁ : Arrow.mk g₁ ⟶ Arrow.mk g₂
α₂ : Arrow.mk f₂ ⟶ Arrow.mk f₃
inst✝⁵ : HasImageMap α₂
β₂ : Arrow.mk g₂ ⟶ Arrow.mk g₃
inst✝⁴ : HasCokernel (imageToKernel f g w)
inst✝³ : HasCokernel (imageToKernel f' g' w')
inst✝² : HasCokernel (imageToKernel f₁ g₁ w₁)
inst✝¹ : HasCokernel (imageToKernel f₂ g₂ w₂)
inst✝ : HasCokernel (imageToKernel f₃ g₃ w₃)
⊢ map w w (𝟙 (Arrow.mk f)) (𝟙 (Arrow.mk g)) (_ : (𝟙 (Arrow.mk f)).right = (𝟙 (Arrow.mk f)).right) = 𝟙 (homology f g w)

tactic: simp only [homology.π_map, kernelSubobjectMap_id, Category.id_comp, Category.comp_id]
state_before: case p
ι : Type ?u.123641
V : Type u
inst✝¹⁹ : Category V
inst✝¹⁸ : HasZeroMorphisms V
A B C : V
f : A ⟶ B
inst✝¹⁷ : HasImage f
g : B ⟶ C
inst✝¹⁶ : HasKernel g
w : f ≫ g = 0
A' B' C' : V
f' : A' ⟶ B'
inst✝¹⁵ : HasImage f'
g' : B' ⟶ C'
inst✝¹⁴ : HasKernel g'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
inst✝¹³ : HasImageMap α
β : Arrow.mk g ⟶ Arrow.mk g'
A₁ B₁ C₁ : V
f₁ : A₁ ⟶ B₁
inst✝¹² : HasImage f₁
g₁ : B₁ ⟶ C₁
inst✝¹¹ : HasKernel g₁
w₁ : f₁ ≫ g₁ = 0
A₂ B₂ C₂ : V
f₂ : A₂ ⟶ B₂
inst✝¹⁰ : HasImage f₂
g₂ : B₂ ⟶ C₂
inst✝⁹ : HasKernel g₂
w₂ : f₂ ≫ g₂ = 0
A₃ B₃ C₃ : V
f₃ : A₃ ⟶ B₃
inst✝⁸ : HasImage f₃
g₃ : B₃ ⟶ C₃
inst✝⁷ : HasKernel g₃
w₃ : f₃ ≫ g₃ = 0
α₁ : Arrow.mk f₁ ⟶ Arrow.mk f₂
inst✝⁶ : HasImageMap α₁
β₁ : Arrow.mk g₁ ⟶ Arrow.mk g₂
α₂ : Arrow.mk f₂ ⟶ Arrow.mk f₃
inst✝⁵ : HasImageMap α₂
β₂ : Arrow.mk g₂ ⟶ Arrow.mk g₃
inst✝⁴ : HasCokernel (imageToKernel f g w)
inst✝³ : HasCokernel (imageToKernel f' g' w')
inst✝² : HasCokernel (imageToKernel f₁ g₁ w₁)
inst✝¹ : HasCokernel (imageToKernel f₂ g₂ w₂)
inst✝ : HasCokernel (imageToKernel f₃ g₃ w₃)
⊢ π f g w ≫ map w w (𝟙 (Arrow.mk f)) (𝟙 (Arrow.mk g)) (_ : (𝟙 (Arrow.mk f)).right = (𝟙 (Arrow.mk f)).right) =
    π f g w ≫ 𝟙 (homology f g w)
Theorem: PGame.add_lf_add_right
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← PGame.not_le] at h⊢
state_before: y z : PGame
h : y ⧏ z
x : PGame
this : z + x ≤ y + x → z ≤ y
⊢ y + x ⧏ z + x

tactic: exact mt this h
state_before: y z : PGame
h : ¬z ≤ y
x : PGame
this : z + x ≤ y + x → z ≤ y
⊢ ¬z + x ≤ y + x