tasksource/leandojo huggingface dataset:
Theorem: Int.ModEq.pow
File: Mathlib/Data/Int/ModEq.lean

tactic: induction' m with d hd
state_before: m✝ n a b c d : ℤ
m : ℕ
h : a ≡ b [ZMOD n]
⊢ a ^ m ≡ b ^ m [ZMOD n]

tactic: rw [pow_succ, pow_succ]
state_before: case succ
m n a b c d✝ : ℤ
h : a ≡ b [ZMOD n]
d : ℕ
hd : a ^ d ≡ b ^ d [ZMOD n]
⊢ a ^ Nat.succ d ≡ b ^ Nat.succ d [ZMOD n]

tactic: exact h.mul hd
state_before: case succ
m n a b c d✝ : ℤ
h : a ≡ b [ZMOD n]
d : ℕ
hd : a ^ d ≡ b ^ d [ZMOD n]
⊢ a * a ^ d ≡ b * b ^ d [ZMOD n]

tactic: rfl
state_before: case zero
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
⊢ a ^ Nat.zero ≡ b ^ Nat.zero [ZMOD n]
Theorem: LinearPMap.mem_domain_iff_of_eq_graph
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: simp_rw [mem_domain_iff, h]
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.590759
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type ?u.591275
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y : M
f g : E →ₗ.[R] F
h : graph f = graph g
x : E
⊢ x ∈ f.domain ↔ x ∈ g.domain
Theorem: IsPGroup.of_card
File: Mathlib/GroupTheory/PGroup.lean

tactic: rw [← hG, pow_card_eq_one]
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
inst✝ : Fintype G
n : ℕ
hG : card G = p ^ n
g : G
⊢ g ^ p ^ n = 1
Theorem: RatFunc.algebraMap_apply_div
File: Mathlib/FieldTheory/RatFunc.lean

tactic: convert coe_div (algebraMap F[X] (RatFunc F) p) (algebraMap F[X] (RatFunc F) q) <;>
  rw [← mk_one, coe_def, coeAlgHom, mk_eq_div, liftAlgHom_apply_div, map_one, div_one,
    Algebra.ofId_apply]
state_before: K F : Type u
inst✝ : Field F
p q : F[X]
f g : RatFunc F
⊢ ↑(algebraMap (RatFunc F) (LaurentSeries F)) (↑(algebraMap F[X] (RatFunc F)) p / ↑(algebraMap F[X] (RatFunc F)) q) =
    ↑(algebraMap F[X] (LaurentSeries F)) p / ↑(algebraMap F[X] (LaurentSeries F)) q
Theorem: Trivialization.apply_symm_apply_eq_coordChangeL
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: rw [e.mk_coordChangeL e' hb, e.mk_symm hb.1]
state_before: R : Type u_4
B : Type u_1
F : Type u_2
E : B → Type u_3
inst✝⁹ : Semiring R
inst✝⁸ : TopologicalSpace F
inst✝⁷ : TopologicalSpace B
inst✝⁶ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F TotalSpace.proj
x : TotalSpace E
b✝ : B
y : E b✝
inst✝⁵ : AddCommMonoid F
inst✝⁴ : Module R F
inst✝³ : (x : B) → AddCommMonoid (E x)
inst✝² : (x : B) → Module R (E x)
e e' : Trivialization F TotalSpace.proj
inst✝¹ : Trivialization.IsLinear R e
inst✝ : Trivialization.IsLinear R e'
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
v : F
⊢ ↑e' (↑(LocalHomeomorph.symm e.toLocalHomeomorph) (b, v)) = (b, ↑(coordChangeL R e e' b) v)
Theorem: Num.cast_bit1
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← bit1_of_bit1, _root_.bit1, bit0_of_bit0, cast_add, cast_bit0]
state_before: α : Type u_1
inst✝ : Semiring α
n : Num
⊢ ↑(Num.bit1 n) = _root_.bit1 ↑n

tactic: rfl
state_before: α : Type u_1
inst✝ : Semiring α
n : Num
⊢ _root_.bit0 ↑n + ↑1 = _root_.bit1 ↑n
Theorem: Set.Nontrivial.einfsep_lt_top
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: rw [lt_top_iff_ne_top]
state_before: α : Type u_1
β : Type ?u.50351
inst✝ : PseudoMetricSpace α
s : Set α
hs : Set.Nontrivial s
⊢ einfsep s < ⊤

tactic: exact hs.einfsep_ne_top
state_before: α : Type u_1
β : Type ?u.50351
inst✝ : PseudoMetricSpace α
s : Set α
hs : Set.Nontrivial s
⊢ einfsep s ≠ ⊤
Theorem: Set.Finite.iSup_biInf_of_monotone
File: Mathlib/Data/Set/Finite.lean

tactic: induction' s, hs using Set.Finite.dinduction_on with a s _ _ ihs hf
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
ι' : Type u_2
α : Type u_3
inst✝³ : Preorder ι'
inst✝² : Nonempty ι'
inst✝¹ : IsDirected ι' fun x x_1 => x ≤ x_1
inst✝ : Order.Frame α
s : Set ι
hs : Set.Finite s
f : ι → ι' → α
hf : ∀ (i : ι), i ∈ s → Monotone (f i)
⊢ (⨆ (j : ι'), ⨅ (i : ι) (_ : i ∈ s), f i j) = ⨅ (i : ι) (_ : i ∈ s), ⨆ (j : ι'), f i j

tactic: simp [iSup_const]
state_before: case H0
α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
ι' : Type u_2
α : Type u_3
inst✝³ : Preorder ι'
inst✝² : Nonempty ι'
inst✝¹ : IsDirected ι' fun x x_1 => x ≤ x_1
inst✝ : Order.Frame α
s : Set ι
f : ι → ι' → α
hf✝ : ∀ (i : ι), i ∈ s → Monotone (f i)
hf : ∀ (i : ι), i ∈ ∅ → Monotone (f i)
⊢ (⨆ (j : ι'), ⨅ (i : ι) (_ : i ∈ ∅), f i j) = ⨅ (i : ι) (_ : i ∈ ∅), ⨆ (j : ι'), f i j

tactic: rw [ball_insert_iff] at hf
state_before: case H1
α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
ι' : Type u_2
α : Type u_3
inst✝³ : Preorder ι'
inst✝² : Nonempty ι'
inst✝¹ : IsDirected ι' fun x x_1 => x ≤ x_1
inst✝ : Order.Frame α
s✝ : Set ι
f : ι → ι' → α
hf✝ : ∀ (i : ι), i ∈ s✝ → Monotone (f i)
a : ι
s : Set ι
a✝ : ¬a ∈ s
h✝ : Set.Finite s
ihs :
  (∀ (i : ι), i ∈ s → Monotone (f i)) →
    (⨆ (j : ι'), ⨅ (i : ι) (_ : i ∈ s), f i j) = ⨅ (i : ι) (_ : i ∈ s), ⨆ (j : ι'), f i j
hf : ∀ (i : ι), i ∈ insert a s → Monotone (f i)
⊢ (⨆ (j : ι'), ⨅ (i : ι) (_ : i ∈ insert a s), f i j) = ⨅ (i : ι) (_ : i ∈ insert a s), ⨆ (j : ι'), f i j

tactic: simp only [iInf_insert, ← ihs hf.2]
state_before: case H1
α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
ι' : Type u_2
α : Type u_3
inst✝³ : Preorder ι'
inst✝² : Nonempty ι'
inst✝¹ : IsDirected ι' fun x x_1 => x ≤ x_1
inst✝ : Order.Frame α
s✝ : Set ι
f : ι → ι' → α
hf✝ : ∀ (i : ι), i ∈ s✝ → Monotone (f i)
a : ι
s : Set ι
a✝ : ¬a ∈ s
h✝ : Set.Finite s
ihs :
  (∀ (i : ι), i ∈ s → Monotone (f i)) →
    (⨆ (j : ι'), ⨅ (i : ι) (_ : i ∈ s), f i j) = ⨅ (i : ι) (_ : i ∈ s), ⨆ (j : ι'), f i j
hf : Monotone (f a) ∧ ∀ (x : ι), x ∈ s → Monotone (f x)
⊢ (⨆ (j : ι'), ⨅ (i : ι) (_ : i ∈ insert a s), f i j) = ⨅ (i : ι) (_ : i ∈ insert a s), ⨆ (j : ι'), f i j

tactic: exact iSup_inf_of_monotone hf.1 fun j₁ j₂ hj => iInf₂_mono fun i hi => hf.2 i hi hj
state_before: case H1
α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
ι' : Type u_2
α : Type u_3
inst✝³ : Preorder ι'
inst✝² : Nonempty ι'
inst✝¹ : IsDirected ι' fun x x_1 => x ≤ x_1
inst✝ : Order.Frame α
s✝ : Set ι
f : ι → ι' → α
hf✝ : ∀ (i : ι), i ∈ s✝ → Monotone (f i)
a : ι
s : Set ι
a✝ : ¬a ∈ s
h✝ : Set.Finite s
ihs :
  (∀ (i : ι), i ∈ s → Monotone (f i)) →
    (⨆ (j : ι'), ⨅ (i : ι) (_ : i ∈ s), f i j) = ⨅ (i : ι) (_ : i ∈ s), ⨆ (j : ι'), f i j
hf : Monotone (f a) ∧ ∀ (x : ι), x ∈ s → Monotone (f x)
⊢ (⨆ (j : ι'), f a j ⊓ ⨅ (x : ι) (_ : x ∈ s), f x j) = (⨆ (j : ι'), f a j) ⊓ ⨆ (j : ι'), ⨅ (i : ι) (_ : i ∈ s), f i j
Theorem: Set.image_const_add_Ioi
File: Mathlib/Data/Set/Intervals/Monoid.lean

tactic: simp only [add_comm a, image_add_const_Ioi]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ (fun x => a + x) '' Ioi b = Ioi (a + b)
Theorem: Int.toNat_add_toNat_neg_eq_norm
File: Mathlib/Analysis/NormedSpace/Int.lean

tactic: simpa only [NNReal.coe_nat_cast, NNReal.coe_add] using
  congrArg NNReal.toReal (toNat_add_toNat_neg_eq_nnnorm n)
state_before: n : ℤ
⊢ ↑(toNat n) + ↑(toNat (-n)) = ‖n‖
Theorem: SimpleGraph.partitionable_iff_colorable
File: Mathlib/Combinatorics/SimpleGraph/Partition.lean

tactic: constructor
state_before: V : Type u
G : SimpleGraph V
n : ℕ
⊢ Partitionable G n ↔ Colorable G n

tactic: rintro ⟨P, hf, hc⟩
state_before: case mp
V : Type u
G : SimpleGraph V
n : ℕ
⊢ Partitionable G n → Colorable G n

tactic: have : Fintype P.parts := hf.fintype
state_before: case mp.intro.intro
V : Type u
G : SimpleGraph V
n : ℕ
P : Partition G
hf : Set.Finite P.parts
hc : Finset.card (Set.Finite.toFinset hf) ≤ n
⊢ Colorable G n

tactic: rw [Set.Finite.card_toFinset hf] at hc
state_before: case mp.intro.intro
V : Type u
G : SimpleGraph V
n : ℕ
P : Partition G
hf : Set.Finite P.parts
hc : Finset.card (Set.Finite.toFinset hf) ≤ n
this : Fintype ↑P.parts
⊢ Colorable G n

tactic: apply P.to_colorable.mono hc
state_before: case mp.intro.intro
V : Type u
G : SimpleGraph V
n : ℕ
P : Partition G
hf : Set.Finite P.parts
this : Fintype ↑P.parts
hc : Fintype.card ↑P.parts ≤ n
⊢ Colorable G n

tactic: rintro ⟨C⟩
state_before: case mpr
V : Type u
G : SimpleGraph V
n : ℕ
⊢ Colorable G n → Partitionable G n

tactic: refine' ⟨C.toPartition, C.colorClasses_finite, le_trans _ (Fintype.card_fin n).le⟩
state_before: case mpr.intro
V : Type u
G : SimpleGraph V
n : ℕ
C : Coloring G (Fin n)
⊢ Partitionable G n

tactic: generalize_proofs h
state_before: case mpr.intro
V : Type u
G : SimpleGraph V
n : ℕ
C : Coloring G (Fin n)
⊢ Finset.card (Set.Finite.toFinset (_ : Set.Finite (Coloring.colorClasses C))) ≤ Fintype.card (Fin n)

tactic: haveI : Fintype C.colorClasses := C.colorClasses_finite.fintype
state_before: case mpr.intro
V : Type u
G : SimpleGraph V
n : ℕ
C : Coloring G (Fin n)
h : Set.Finite (Coloring.colorClasses C)
⊢ Finset.card (Set.Finite.toFinset h) ≤ Fintype.card (Fin n)

tactic: rw [h.card_toFinset]
state_before: case mpr.intro
V : Type u
G : SimpleGraph V
n : ℕ
C : Coloring G (Fin n)
h : Set.Finite (Coloring.colorClasses C)
this : Fintype ↑(Coloring.colorClasses C)
⊢ Finset.card (Set.Finite.toFinset h) ≤ Fintype.card (Fin n)

tactic: exact C.card_colorClasses_le
state_before: case mpr.intro
V : Type u
G : SimpleGraph V
n : ℕ
C : Coloring G (Fin n)
h : Set.Finite (Coloring.colorClasses C)
this : Fintype ↑(Coloring.colorClasses C)
⊢ Fintype.card ↑(Coloring.colorClasses C) ≤ Fintype.card (Fin n)
Theorem: Set.image2_left_comm
File: Mathlib/Data/Set/NAry.lean

tactic: rw [image2_swap f', image2_swap f]
state_before: α : Type u_2
α' : Type ?u.41219
β : Type u_4
β' : Type ?u.41225
γ : Type u_5
γ' : Type ?u.41231
δ : Type u_3
δ' : Type u_6
ε : Type u_1
ε' : Type ?u.41243
ζ : Type ?u.41246
ζ' : Type ?u.41249
ν : Type ?u.41252
f✝ f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
⊢ image2 f s (image2 g t u) = image2 g' t (image2 f' s u)

tactic: exact image2_assoc fun _ _ _ => h_left_comm _ _ _
state_before: α : Type u_2
α' : Type ?u.41219
β : Type u_4
β' : Type ?u.41225
γ : Type u_5
γ' : Type ?u.41231
δ : Type u_3
δ' : Type u_6
ε : Type u_1
ε' : Type ?u.41243
ζ : Type ?u.41246
ζ' : Type ?u.41249
ν : Type ?u.41252
f✝ f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → δ → ε
g : β → γ → δ
f' : α → γ → δ'
g' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), f a (g b c) = g' b (f' a c)
⊢ image2 (fun a b => f b a) (image2 g t u) s = image2 g' t (image2 (fun a b => f' b a) u s)
Theorem: Nat.factors_eq
File: Mathlib/RingTheory/Int/Basic.lean

tactic: cases n
state_before: n : ℕ
⊢ normalizedFactors n = ↑(factors n)

tactic: case zero => simp
state_before: case zero

⊢ normalizedFactors zero = ↑(factors zero)

case succ
n✝ : ℕ
⊢ normalizedFactors (succ n✝) = ↑(factors (succ n✝))

tactic: simp
state_before: ⊢ normalizedFactors zero = ↑(factors zero)

tactic: rw [← Multiset.rel_eq, ← associated_eq_eq]
state_before: n : ℕ
⊢ normalizedFactors (succ n) = ↑(factors (succ n))

tactic: apply UniqueFactorizationMonoid.factors_unique irreducible_of_normalized_factor _
state_before: n : ℕ
⊢ Multiset.Rel (fun x x_1 => Associated x x_1) (normalizedFactors (succ n)) ↑(factors (succ n))

tactic: rw [Multiset.coe_prod, Nat.prod_factors n.succ_ne_zero]
state_before: n : ℕ
⊢ Associated (Multiset.prod (normalizedFactors (succ n))) (Multiset.prod ↑(factors (succ n)))

tactic: apply normalizedFactors_prod (Nat.succ_ne_zero _)
state_before: n : ℕ
⊢ Associated (Multiset.prod (normalizedFactors (succ n))) (succ n)

tactic: intro x hx
state_before: n : ℕ
⊢ ∀ (x : ℕ), x ∈ ↑(factors (succ n)) → Irreducible x

tactic: rw [Nat.irreducible_iff_prime, ← Nat.prime_iff]
state_before: n x : ℕ
hx : x ∈ ↑(factors (succ n))
⊢ Irreducible x

tactic: exact Nat.prime_of_mem_factors hx
state_before: n x : ℕ
hx : x ∈ ↑(factors (succ n))
⊢ Prime x
Theorem: Polynomial.Separable.mul
File: Mathlib/FieldTheory/Separable.lean

tactic: rw [separable_def, derivative_mul]
state_before: R : Type u
inst✝ : CommRing R
f g : R[X]
hf : Separable f
hg : Separable g
h : IsCoprime f g
⊢ Separable (f * g)

tactic: exact
  ((hf.mul_right h).add_mul_left_right _).mul_left ((h.symm.mul_right hg).mul_add_right_right _)
state_before: R : Type u
inst✝ : CommRing R
f g : R[X]
hf : Separable f
hg : Separable g
h : IsCoprime f g
⊢ IsCoprime (f * g) (↑derivative f * g + f * ↑derivative g)
Theorem: Subgroup.comap_sup_eq_of_le_range
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [map_comap_eq, map_sup, map_comap_eq, map_comap_eq, inf_eq_right.mpr hH,
  inf_eq_right.mpr hK, inf_eq_right.mpr (sup_le hH hK)]
state_before: G : Type u_2
G' : Type ?u.606769
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.606778
inst✝¹ : AddGroup A
N : Type u_1
inst✝ : Group N
f : G →* N
H K : Subgroup N
hH : H ≤ range f
hK : K ≤ range f
⊢ map f (comap f H ⊔ comap f K) = map f (comap f (H ⊔ K))
Theorem: ContinuousMap.mem_compactConvergenceUniformity
File: Mathlib/Topology/UniformSpace/CompactConvergence.lean

tactic: simp only [hasBasis_compactConvergenceUniformity_aux.mem_iff, exists_prop, Prod.exists,
  and_assoc]
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
X : Set (C(α, β) × C(α, β))
⊢ X ∈ compactConvergenceUniformity ↔ ∃ K V _hK _hV, {fg | ∀ (x : α), x ∈ K → (↑fg.fst x, ↑fg.snd x) ∈ V} ⊆ X
Theorem: Complex.hasStrictDerivAt_cosh
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

tactic: simp only [sinh, div_eq_mul_inv]
state_before: x : ℂ
⊢ HasStrictDerivAt cosh (sinh x) x

tactic: convert ((hasStrictDerivAt_exp x).add (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
  using 1
state_before: x : ℂ
⊢ HasStrictDerivAt cosh ((exp x - exp (-x)) * 2⁻¹) x

tactic: rw [id, mul_neg_one, sub_eq_add_neg]
state_before: case h.e'_7
x : ℂ
⊢ (exp x - exp (-x)) * 2⁻¹ = (exp x + exp (-id x) * -1) * 2⁻¹
Theorem: AddCommGroup.modEq_sub_iff_add_modEq'
File: Mathlib/Algebra/ModEq.lean

tactic: simp [ModEq, sub_sub]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ a ≡ b - c [PMOD p] ↔ c + a ≡ b [PMOD p]
Theorem: Polynomial.trailingDegree_eq_natTrailingDegree
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: let ⟨n, hn⟩ :=
  not_forall.1 (mt Option.eq_none_iff_forall_not_mem.2 (mt trailingDegree_eq_top.1 hp))
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
⊢ trailingDegree p = ↑(natTrailingDegree p)

tactic: have hn : trailingDegree p = n := Classical.not_not.1 hn
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
n : ℕ
hn : ¬¬n ∈ trailingDegree p
⊢ trailingDegree p = ↑(natTrailingDegree p)

tactic: rw [natTrailingDegree, hn]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
n : ℕ
hn✝ : ¬¬n ∈ trailingDegree p
hn : trailingDegree p = ↑n
⊢ trailingDegree p = ↑(natTrailingDegree p)

tactic: rfl
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
n : ℕ
hn✝ : ¬¬n ∈ trailingDegree p
hn : trailingDegree p = ↑n
⊢ ↑n = ↑(Option.getD (↑n) 0)
Theorem: Projectivization.Subspace.span_eq_sInf
File: Mathlib/LinearAlgebra/ProjectiveSpace/Subspace.lean

tactic: ext x
state_before: K : Type u_2
V : Type u_1
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Set (ℙ K V)
⊢ span S = sInf {W | S ⊆ ↑W}

tactic: simp_rw [mem_carrier_iff, mem_span x]
state_before: case carrier.h
K : Type u_2
V : Type u_1
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Set (ℙ K V)
x : ℙ K V
⊢ x ∈ (span S).carrier ↔ x ∈ (sInf {W | S ⊆ ↑W}).carrier

tactic: refine ⟨fun hx => ?_, fun hx W hW => ?_⟩
state_before: case carrier.h
K : Type u_2
V : Type u_1
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Set (ℙ K V)
x : ℙ K V
⊢ (∀ (W : Subspace K V), S ⊆ ↑W → x ∈ W) ↔ x ∈ sInf {W | S ⊆ ↑W}

tactic: rintro W ⟨T, hT, rfl⟩
state_before: case carrier.h.refine_1
K : Type u_2
V : Type u_1
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Set (ℙ K V)
x : ℙ K V
hx : ∀ (W : Subspace K V), S ⊆ ↑W → x ∈ W
⊢ x ∈ sInf {W | S ⊆ ↑W}

tactic: exact hx T hT
state_before: case carrier.h.refine_1.intro.intro
K : Type u_2
V : Type u_1
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Set (ℙ K V)
x : ℙ K V
hx : ∀ (W : Subspace K V), S ⊆ ↑W → x ∈ W
T : Subspace K V
hT : T ∈ {W | S ⊆ ↑W}
⊢ x ∈ ↑T

tactic: exact (@sInf_le _ _ { W : Subspace K V | S ⊆ ↑W } W hW) hx
state_before: case carrier.h.refine_2
K : Type u_2
V : Type u_1
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Set (ℙ K V)
x : ℙ K V
hx : x ∈ sInf {W | S ⊆ ↑W}
W : Subspace K V
hW : S ⊆ ↑W
⊢ x ∈ W
Theorem: CategoryTheory.Iso.cancel_iso_inv_right_assoc
File: Mathlib/CategoryTheory/Iso.lean

tactic: simp only [← Category.assoc, cancel_mono]
state_before: C : Type u
inst✝ : Category C
X✝ Y✝ Z✝ W X X' Y Z : C
f : W ⟶ X
g : X ⟶ Y
f' : W ⟶ X'
g' : X' ⟶ Y
h : Z ≅ Y
⊢ f ≫ g ≫ h.inv = f' ≫ g' ≫ h.inv ↔ f ≫ g = f' ≫ g'
Theorem: Finset.prod_int_mod
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [Finset.prod, Multiset.map_map]
state_before: ι : Type ?u.877667
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
s : Finset α
n : ℤ
f : α → ℤ
⊢ Multiset.prod (Multiset.map (fun x => x % n) (Multiset.map (fun i => f i) s.val)) % n = (∏ i in s, f i % n) % n

tactic: rfl
state_before: ι : Type ?u.877667
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
s : Finset α
n : ℤ
f : α → ℤ
⊢ Multiset.prod (Multiset.map ((fun x => x % n) ∘ fun i => f i) s.val) % n =
    Multiset.prod (Multiset.map (fun i => f i % n) s.val) % n
Theorem: SeparatedNhds.union_left
File: Mathlib/Topology/Separation.lean

tactic: simpa only [separatedNhds_iff_disjoint, nhdsSet_union, disjoint_sup_left] using And.intro
state_before: α : Type u
β : Type v
inst✝ : TopologicalSpace α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ SeparatedNhds s u → SeparatedNhds t u → SeparatedNhds (s ∪ t) u
Theorem: MonoidAlgebra.support_single_mul
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

tactic: classical
  ext
  simp only [support_single_mul_eq_image f hr (isLeftRegular_of_leftCancelSemigroup x), mem_image,
    mem_map, mulLeftEmbedding_apply]
state_before: k : Type u₁
G : Type u₂
inst✝¹ : Semiring k
inst✝ : LeftCancelSemigroup G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
⊢ (single x r * f).support = map (mulLeftEmbedding x) f.support

tactic: ext
state_before: k : Type u₁
G : Type u₂
inst✝¹ : Semiring k
inst✝ : LeftCancelSemigroup G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
⊢ (single x r * f).support = map (mulLeftEmbedding x) f.support

tactic: simp only [support_single_mul_eq_image f hr (isLeftRegular_of_leftCancelSemigroup x), mem_image,
  mem_map, mulLeftEmbedding_apply]
state_before: case a
k : Type u₁
G : Type u₂
inst✝¹ : Semiring k
inst✝ : LeftCancelSemigroup G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x a✝ : G
⊢ a✝ ∈ (single x r * f).support ↔ a✝ ∈ map (mulLeftEmbedding x) f.support
Theorem: Finset.Set.Sized.shadow
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: intro A h
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
h𝒜 : Set.Sized r ↑𝒜
⊢ Set.Sized (r - 1) ↑((∂ ) 𝒜)

tactic: obtain ⟨A, hA, i, hi, rfl⟩ := mem_shadow_iff.1 h
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
h𝒜 : Set.Sized r ↑𝒜
A : Finset α
h : A ∈ ↑((∂ ) 𝒜)
⊢ card A = r - 1

tactic: rw [card_erase_of_mem hi, h𝒜 hA]
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
h𝒜 : Set.Sized r ↑𝒜
A : Finset α
hA : A ∈ 𝒜
i : α
hi : i ∈ A
h : erase A i ∈ ↑((∂ ) 𝒜)
⊢ card (erase A i) = r - 1
Theorem: TopCat.induced_of_isLimit
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

tactic: let homeo := homeoOfIso (hC.conePointUniqueUpToIso (limitConeInfiIsLimit F))
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
⊢ C.pt.str = ⨅ (j : J), induced ((forget TopCat).map (C.π.app j)) (F.obj j).str

tactic: refine' homeo.inducing.induced.trans _
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
homeo : ↑C.pt ≃ₜ ↑(limitConeInfi F).pt := homeoOfIso (IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F))
⊢ C.pt.str = ⨅ (j : J), induced ((forget TopCat).map (C.π.app j)) (F.obj j).str

tactic: change induced homeo (⨅ j : J, _) = _
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
homeo : ↑C.pt ≃ₜ ↑(limitConeInfi F).pt := homeoOfIso (IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F))
⊢ induced (↑homeo) (topologicalSpace_coe (limitConeInfi F).pt) =
    ⨅ (j : J), induced ((forget TopCat).map (C.π.app j)) (F.obj j).str

tactic: simp [induced_iInf, induced_compose]
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
homeo : ↑C.pt ≃ₜ ↑(limitConeInfi F).pt := homeoOfIso (IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F))
⊢ induced (↑homeo) (⨅ (j : J), induced ((Types.limitCone (F ⋙ forget TopCat)).π.app j) (F.obj j).str) =
    ⨅ (j : J), induced ((forget TopCat).map (C.π.app j)) (F.obj j).str

tactic: rfl
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
C : Cone F
hC : IsLimit C
homeo : ↑C.pt ≃ₜ ↑(limitConeInfi F).pt := homeoOfIso (IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F))
⊢ (⨅ (i : J),
      induced
        ((Types.limitCone (F ⋙ forget TopCat)).π.app i ∘
          ↑(homeoOfIso (IsLimit.conePointUniqueUpToIso hC (limitConeInfiIsLimit F))))
        (F.obj i).str) =
    ⨅ (j : J), induced ((forget TopCat).map (C.π.app j)) (F.obj j).str