tasksource/leandojo huggingface dataset:
Theorem: TensorPower.algebraMap₀_eq_smul_one
File: Mathlib/LinearAlgebra/TensorPower.lean

tactic: simp [algebraMap₀]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r : R
⊢ ↑algebraMap₀ r = r • GradedMonoid.GOne.one

tactic: congr
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r : R
⊢ r • ↑(tprod R) isEmptyElim = r • GradedMonoid.GOne.one
Theorem: le_mul_right
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

tactic: simp
state_before: α : Type u
inst✝ : CanonicallyOrderedMonoid α
a b c d : α
h : a ≤ b
⊢ a = a * 1
Theorem: CategoryTheory.NatTrans.id_hcomp_app
File: Mathlib/CategoryTheory/Functor/Category.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G H✝ I : C ⥤ D
H : E ⥤ C
α : F ⟶ G
X : E
⊢ (𝟙 H ◫ α).app X = α.app (H.obj X)
Theorem: MvPolynomial.vars_prod
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical
induction s using Finset.induction_on with
| empty => simp
| insert hs hsub =>
  simp only [hs, Finset.biUnion_insert, Finset.prod_insert, not_false_iff]
  apply Finset.Subset.trans (vars_mul _ _)
  exact Finset.union_subset_union (Finset.Subset.refl _) hsub
state_before: R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.166872
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
inst✝ : DecidableEq σ
s : Finset ι
f : ι → MvPolynomial σ R
⊢ vars (∏ i in s, f i) ⊆ Finset.biUnion s fun i => vars (f i)

tactic: induction s using Finset.induction_on with
| empty => simp
| insert hs hsub =>
  simp only [hs, Finset.biUnion_insert, Finset.prod_insert, not_false_iff]
  apply Finset.Subset.trans (vars_mul _ _)
  exact Finset.union_subset_union (Finset.Subset.refl _) hsub
state_before: R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.166872
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
inst✝ : DecidableEq σ
s : Finset ι
f : ι → MvPolynomial σ R
⊢ vars (∏ i in s, f i) ⊆ Finset.biUnion s fun i => vars (f i)

tactic: simp
state_before: case empty
R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.166872
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
inst✝ : DecidableEq σ
f : ι → MvPolynomial σ R
⊢ vars (∏ i in ∅, f i) ⊆ Finset.biUnion ∅ fun i => vars (f i)

tactic: simp only [hs, Finset.biUnion_insert, Finset.prod_insert, not_false_iff]
state_before: case insert
R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.166872
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
inst✝ : DecidableEq σ
f : ι → MvPolynomial σ R
a✝ : ι
s✝ : Finset ι
hs : ¬a✝ ∈ s✝
hsub : vars (∏ i in s✝, f i) ⊆ Finset.biUnion s✝ fun i => vars (f i)
⊢ vars (∏ i in insert a✝ s✝, f i) ⊆ Finset.biUnion (insert a✝ s✝) fun i => vars (f i)

tactic: apply Finset.Subset.trans (vars_mul _ _)
state_before: case insert
R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.166872
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
inst✝ : DecidableEq σ
f : ι → MvPolynomial σ R
a✝ : ι
s✝ : Finset ι
hs : ¬a✝ ∈ s✝
hsub : vars (∏ i in s✝, f i) ⊆ Finset.biUnion s✝ fun i => vars (f i)
⊢ vars (f a✝ * ∏ i in s✝, f i) ⊆ vars (f a✝) ∪ Finset.biUnion s✝ fun i => vars (f i)

tactic: exact Finset.union_subset_union (Finset.Subset.refl _) hsub
state_before: case insert
R : Type u
S : Type v
σ : Type u_2
τ : Type ?u.166872
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
ι : Type u_1
inst✝ : DecidableEq σ
f : ι → MvPolynomial σ R
a✝ : ι
s✝ : Finset ι
hs : ¬a✝ ∈ s✝
hsub : vars (∏ i in s✝, f i) ⊆ Finset.biUnion s✝ fun i => vars (f i)
⊢ vars (f a✝) ∪ vars (∏ i in s✝, f i) ⊆ vars (f a✝) ∪ Finset.biUnion s✝ fun i => vars (f i)
Theorem: rotationOf_rotation
File: Mathlib/Analysis/Complex/Isometry.lean

tactic: simp
state_before: a : { x // x ∈ circle }
⊢ ↑(rotationOf (↑rotation a)) = ↑a
Theorem: IsUnit.mul_val_inv
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [←h.unit.mul_inv]
state_before: α : Type u
M : Type u_1
N : Type ?u.65932
inst✝ : Monoid M
a b c : M
h : IsUnit a
⊢ a * ↑(IsUnit.unit h)⁻¹ = 1

tactic: congr
state_before: α : Type u
M : Type u_1
N : Type ?u.65932
inst✝ : Monoid M
a b c : M
h : IsUnit a
⊢ a * ↑(IsUnit.unit h)⁻¹ = ↑(IsUnit.unit h) * ↑(IsUnit.unit h)⁻¹
Theorem: CategoryTheory.Bifunctor.map_id_comp
File: Mathlib/CategoryTheory/Products/Bifunctor.lean

tactic: rw [← Functor.map_comp, prod_comp, Category.comp_id]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝² : Category C
inst✝¹ : Category D
inst✝ : Category E
F : C × D ⥤ E
W : C
X Y Z : D
f : X ⟶ Y
g : Y ⟶ Z
⊢ F.map (𝟙 W, f ≫ g) = F.map (𝟙 W, f) ≫ F.map (𝟙 W, g)
Theorem: AffineMap.span_eq_top_of_surjective
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [← AffineSubspace.map_span, h, map_top_of_surjective f hf]
state_before: k : Type u_5
V₁ : Type u_3
P₁ : Type u_1
V₂ : Type u_4
P₂ : Type u_2
V₃ : Type ?u.579305
P₃ : Type ?u.579308
inst✝⁹ : Ring k
inst✝⁸ : AddCommGroup V₁
inst✝⁷ : Module k V₁
inst✝⁶ : AffineSpace V₁ P₁
inst✝⁵ : AddCommGroup V₂
inst✝⁴ : Module k V₂
inst✝³ : AffineSpace V₂ P₂
inst✝² : AddCommGroup V₃
inst✝¹ : Module k V₃
inst✝ : AffineSpace V₃ P₃
f : P₁ →ᵃ[k] P₂
s : Set P₁
hf : Function.Surjective ↑f
h : affineSpan k s = ⊤
⊢ affineSpan k (↑f '' s) = ⊤
Theorem: PGame.neg_lf_zero_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [neg_lf_iff, neg_zero]
state_before: x : PGame
⊢ -x ⧏ 0 ↔ 0 ⧏ x
Theorem: List.duplicate_cons_iff
File: Mathlib/Data/List/Duplicate.lean

tactic: refine' ⟨fun h => _, fun h => _⟩
state_before: α : Type u_1
l : List α
x y : α
⊢ x ∈+ y :: l ↔ y = x ∧ x ∈ l ∨ x ∈+ l

tactic: cases' h with _ hm _ _ hm
state_before: case refine'_1
α : Type u_1
l : List α
x y : α
h : x ∈+ y :: l
⊢ y = x ∧ x ∈ l ∨ x ∈+ l

tactic: exact Or.inl ⟨rfl, hm⟩
state_before: case refine'_1.cons_mem
α : Type u_1
l : List α
x : α
hm : x ∈ l
⊢ x = x ∧ x ∈ l ∨ x ∈+ l

tactic: exact Or.inr hm
state_before: case refine'_1.cons_duplicate
α : Type u_1
l : List α
x y : α
hm : x ∈+ l
⊢ y = x ∧ x ∈ l ∨ x ∈+ l

tactic: rcases h with (⟨rfl | h⟩ | h)
state_before: case refine'_2
α : Type u_1
l : List α
x y : α
h : y = x ∧ x ∈ l ∨ x ∈+ l
⊢ x ∈+ y :: l

tactic: simpa
state_before: case refine'_2.inl.intro.refl
α : Type u_1
l : List α
x : α
right✝ : x ∈ l
⊢ x ∈+ x :: l

tactic: exact h.cons_duplicate
state_before: case refine'_2.inr
α : Type u_1
l : List α
x y : α
h : x ∈+ l
⊢ x ∈+ y :: l
Theorem: Cardinal.derivBFamily_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [lift_id]
state_before: α : Type ?u.167917
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal → Ordinal
c : Cardinal
hc : IsRegular c
hι : card o < c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal) (hi : i < o) (b : Ordinal), b < ord c → f i hi b < ord c
a : Ordinal
⊢ lift (card o) < c
Theorem: LieSubmodule.submodule_span_le_lieSpan
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [Submodule.span_le]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
⊢ Submodule.span R s ≤ ↑(lieSpan R L s)

tactic: apply subset_lieSpan
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
⊢ s ⊆ ↑↑(lieSpan R L s)
Theorem: Int.add_le_of_le_sub_right
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_le_add_right h b
state_before: a b c : Int
h : a ≤ c - b
⊢ a + b ≤ c

tactic: rwa [Int.sub_add_cancel] at h
state_before: a b c : Int
h✝ : a ≤ c - b
h : a + b ≤ c - b + b
⊢ a + b ≤ c
Theorem: rank_pos_iff_exists_ne_zero
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: rw [← not_iff_not]
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.253674
R : Type u
M : Type v
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : Nontrivial R
⊢ 0 < Module.rank R M ↔ ∃ x, x ≠ 0

tactic: simpa using rank_zero_iff_forall_zero
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.253674
R : Type u
M : Type v
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : Nontrivial R
⊢ ¬0 < Module.rank R M ↔ ¬∃ x, x ≠ 0
Theorem: Polynomial.coeff_restriction
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp only [restriction, coeff_monomial, finset_sum_coeff, mem_support_iff, Finset.sum_ite_eq',
  Ne.def, ite_not]
state_before: R : Type u
S : Type ?u.66016
inst✝ : Ring R
p : R[X]
n : ℕ
⊢ ↑(coeff (restriction p) n) = coeff p n

tactic: split_ifs with h
state_before: R : Type u
S : Type ?u.66016
inst✝ : Ring R
p : R[X]
n : ℕ
⊢ ↑(if coeff p n = 0 then 0 else { val := coeff p n, property := (_ : coeff p n ∈ Subring.closure ↑(frange p)) }) =
    coeff p n

tactic: rw [h]
state_before: case inl
R : Type u
S : Type ?u.66016
inst✝ : Ring R
p : R[X]
n : ℕ
h : coeff p n = 0
⊢ ↑0 = coeff p n

tactic: rfl
state_before: case inl
R : Type u
S : Type ?u.66016
inst✝ : Ring R
p : R[X]
n : ℕ
h : coeff p n = 0
⊢ ↑0 = 0

tactic: rfl
state_before: case inr
R : Type u
S : Type ?u.66016
inst✝ : Ring R
p : R[X]
n : ℕ
h : ¬coeff p n = 0
⊢ ↑{ val := coeff p n, property := (_ : coeff p n ∈ Subring.closure ↑(frange p)) } = coeff p n
Theorem: SimpleGraph.sum_incMatrix_apply_of_mem_edgeSet
File: Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean

tactic: classical
  refine' e.ind _
  intro a b h
  rw [mem_edgeSet] at h
  rw [← Nat.cast_two, ← card_doubleton h.ne]
  simp only [incMatrix_apply', sum_boole, mk'_mem_incidenceSet_iff, h, true_and_iff]
  congr 2
  ext e
  simp only [mem_filter, mem_univ, true_and_iff, mem_insert, mem_singleton]
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype α
inst✝ : NonAssocSemiring R
a b : α
e : Sym2 α
⊢ e ∈ edgeSet G → ∑ a : α, incMatrix R G a e = 2

tactic: refine' e.ind _
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype α
inst✝ : NonAssocSemiring R
a b : α
e : Sym2 α
⊢ e ∈ edgeSet G → ∑ a : α, incMatrix R G a e = 2

tactic: intro a b h
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype α
inst✝ : NonAssocSemiring R
a b : α
e : Sym2 α
⊢ ∀ (x y : α),
    Quotient.mk (Rel.setoid α) (x, y) ∈ edgeSet G → ∑ a : α, incMatrix R G a (Quotient.mk (Rel.setoid α) (x, y)) = 2

tactic: rw [mem_edgeSet] at h
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype α
inst✝ : NonAssocSemiring R
a✝ b✝ : α
e : Sym2 α
a b : α
h : Quotient.mk (Rel.setoid α) (a, b) ∈ edgeSet G
⊢ ∑ a_1 : α, incMatrix R G a_1 (Quotient.mk (Rel.setoid α) (a, b)) = 2

tactic: rw [← Nat.cast_two, ← card_doubleton h.ne]
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype α
inst✝ : NonAssocSemiring R
a✝ b✝ : α
e : Sym2 α
a b : α
h : Adj G a b
⊢ ∑ a_1 : α, incMatrix R G a_1 (Quotient.mk (Rel.setoid α) (a, b)) = 2

tactic: simp only [incMatrix_apply', sum_boole, mk'_mem_incidenceSet_iff, h, true_and_iff]
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype α
inst✝ : NonAssocSemiring R
a✝ b✝ : α
e : Sym2 α
a b : α
h : Adj G a b
⊢ ∑ a_1 : α, incMatrix R G a_1 (Quotient.mk (Rel.setoid α) (a, b)) = ↑(card {a, b})

tactic: congr 2
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype α
inst✝ : NonAssocSemiring R
a✝ b✝ : α
e : Sym2 α
a b : α
h : Adj G a b
⊢ ↑(card (filter (fun x => x = a ∨ x = b) univ)) = ↑(card {a, b})

tactic: ext e
state_before: case e_a.e_s
R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype α
inst✝ : NonAssocSemiring R
a✝ b✝ : α
e : Sym2 α
a b : α
h : Adj G a b
⊢ filter (fun x => x = a ∨ x = b) univ = {a, b}

tactic: simp only [mem_filter, mem_univ, true_and_iff, mem_insert, mem_singleton]
state_before: case e_a.e_s.a
R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝¹ : Fintype α
inst✝ : NonAssocSemiring R
a✝ b✝ : α
e✝ : Sym2 α
a b : α
h : Adj G a b
e : α
⊢ e ∈ filter (fun x => x = a ∨ x = b) univ ↔ e ∈ {a, b}
Theorem: Polynomial.eval₂_gcd_eq_zero
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: rw [EuclideanDomain.gcd_eq_gcd_ab f g, Polynomial.eval₂_add, Polynomial.eval₂_mul,
  Polynomial.eval₂_mul, hf, hg, MulZeroClass.zero_mul, MulZeroClass.zero_mul, zero_add]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : CommSemiring k
ϕ : R →+* k
f g : R[X]
α : k
hf : eval₂ ϕ α f = 0
hg : eval₂ ϕ α g = 0
⊢ eval₂ ϕ α (EuclideanDomain.gcd f g) = 0
Theorem: Subfield.coe_iSup_of_directed
File: Mathlib/FieldTheory/Subfield.lean

tactic: simp [mem_iSup_of_directed hS]
state_before: K : Type u
L : Type v
M : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field M
ι : Sort u_1
hι : Nonempty ι
S : ι → Subfield K
hS : Directed (fun x x_1 => x ≤ x_1) S
x : K
⊢ x ∈ ↑(⨆ (i : ι), S i) ↔ x ∈ ⋃ (i : ι), ↑(S i)
Theorem: IsLocalMaxOn.fderivWithin_eq_zero
File: Mathlib/Analysis/Calculus/LocalExtr.lean

tactic: rw [fderivWithin_zero_of_not_differentiableWithinAt hf]
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMaxOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ ↑(fderivWithin ℝ f s a) y = 0

tactic: rfl
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMaxOn f s a
y : E
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ ↑0 y = 0
Theorem: Polynomial.natDegree_C_mul_le
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: rw [natDegree_C a]
state_before: R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
f : R[X]
⊢ natDegree (↑C a) + natDegree f = 0 + natDegree f
Theorem: AffineSubspace.sup_direction_le
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: simp only [direction_eq_vectorSpan, vectorSpan_def]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
⊢ direction s1 ⊔ direction s2 ≤ direction (s1 ⊔ s2)

tactic: exact
  sup_le
    (sInf_le_sInf fun p hp => Set.Subset.trans (vsub_self_mono (le_sup_left : s1 ≤ s1 ⊔ s2)) hp)
    (sInf_le_sInf fun p hp => Set.Subset.trans (vsub_self_mono (le_sup_right : s2 ≤ s1 ⊔ s2)) hp)
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
⊢ Submodule.span k (↑s1 -ᵥ ↑s1) ⊔ Submodule.span k (↑s2 -ᵥ ↑s2) ≤ Submodule.span k (↑(s1 ⊔ s2) -ᵥ ↑(s1 ⊔ s2))
Theorem: Cardinal.mk_multiset_of_isEmpty
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: simp
state_before: α : Type u
inst✝ : IsEmpty α
⊢ (#α →₀ ℕ) = 1
Theorem: InnerProductGeometry.angle_zero_left
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: unfold angle
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y x : V
⊢ angle 0 x = π / 2

tactic: rw [inner_zero_left, zero_div, Real.arccos_zero]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y x : V
⊢ arccos (inner 0 x / (‖0‖ * ‖x‖)) = π / 2
Theorem: CategoryTheory.Limits.PullbackCone.op_inr
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category C
J : Type u₂
inst✝ : Category J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
c : PullbackCone f g
⊢ PushoutCocone.inr (op c) = (snd c).op
Theorem: Equiv.symm_symm
File: Mathlib/Logic/Equiv/Defs.lean

tactic: cases e
state_before: α : Sort u
β : Sort v
γ : Sort w
e : α ≃ β
⊢ e.symm.symm = e

tactic: rfl
state_before: case mk
α : Sort u
β : Sort v
γ : Sort w
toFun✝ : α → β
invFun✝ : β → α
left_inv✝ : LeftInverse invFun✝ toFun✝
right_inv✝ : Function.RightInverse invFun✝ toFun✝
⊢ { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }.symm.symm =
    { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
Theorem: compactSpace_of_finite_subfamily_closed
File: Mathlib/Topology/SubsetProperties.lean

tactic: simpa using h Z
state_before: α : Type u
β : Type v
ι : Type ?u.76247
π : ι → Type ?u.76252
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
h :
  ∀ {ι : Type u} (Z : ι → Set α),
    (∀ (i : ι), IsClosed (Z i)) → (⋂ (i : ι), Z i) = ∅ → ∃ t, (⋂ (i : ι) (_ : i ∈ t), Z i) = ∅
ι✝ : Type u
Z : ι✝ → Set α
⊢ (∀ (i : ι✝), IsClosed (Z i)) → (univ ∩ ⋂ (i : ι✝), Z i) = ∅ → ∃ t, (univ ∩ ⋂ (i : ι✝) (_ : i ∈ t), Z i) = ∅
Theorem: Subgroup.comap_map_eq
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: refine' le_antisymm _ (sup_le (le_comap_map _ _) (ker_le_comap _ _))
state_before: G : Type u_1
G' : Type ?u.565766
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.565775
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f : G →* N
H : Subgroup G
⊢ comap f (map f H) = H ⊔ ker f

tactic: intro x hx
state_before: G : Type u_1
G' : Type ?u.565766
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.565775
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f : G →* N
H : Subgroup G
⊢ comap f (map f H) ≤ H ⊔ ker f

tactic: simp only [exists_prop, mem_map, mem_comap] at hx
state_before: G : Type u_1
G' : Type ?u.565766
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.565775
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f : G →* N
H : Subgroup G
x : G
hx : x ∈ comap f (map f H)
⊢ x ∈ H ⊔ ker f

tactic: rcases hx with ⟨y, hy, hy'⟩
state_before: G : Type u_1
G' : Type ?u.565766
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.565775
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f : G →* N
H : Subgroup G
x : G
hx : ∃ x_1, x_1 ∈ H ∧ ↑f x_1 = ↑f x
⊢ x ∈ H ⊔ ker f

tactic: rw [← mul_inv_cancel_left y x]
state_before: case intro.intro
G : Type u_1
G' : Type ?u.565766
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.565775
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f : G →* N
H : Subgroup G
x y : G
hy : y ∈ H
hy' : ↑f y = ↑f x
⊢ x ∈ H ⊔ ker f

tactic: exact mul_mem_sup hy (by simp [mem_ker, hy'])
state_before: case intro.intro
G : Type u_1
G' : Type ?u.565766
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.565775
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f : G →* N
H : Subgroup G
x y : G
hy : y ∈ H
hy' : ↑f y = ↑f x
⊢ y * (y⁻¹ * x) ∈ H ⊔ ker f

tactic: simp [mem_ker, hy']
state_before: G : Type u_1
G' : Type ?u.565766
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.565775
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f : G →* N
H : Subgroup G
x y : G
hy : y ∈ H
hy' : ↑f y = ↑f x
⊢ y⁻¹ * x ∈ ker f
Theorem: Homeomorph.mulRight_symm
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: ext
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
a : G
⊢ Homeomorph.symm (Homeomorph.mulRight a) = Homeomorph.mulRight a⁻¹

tactic: rfl
state_before: case H
α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
a x✝ : G
⊢ ↑(Homeomorph.symm (Homeomorph.mulRight a)) x✝ = ↑(Homeomorph.mulRight a⁻¹) x✝
Theorem: ext_nat'
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: intro n
state_before: α : Type ?u.27138
β : Type ?u.27141
A : Type u_1
B : Type ?u.27147
F : Type u_2
inst✝² : AddMonoidWithOne B
inst✝¹ : AddMonoid A
inst✝ : AddMonoidHomClass F ℕ A
f g : F
h : ↑f 1 = ↑g 1
⊢ ∀ (x : ℕ), ↑f x = ↑g x

tactic: induction n with
| zero => simp_rw [Nat.zero_eq, map_zero f, map_zero g]
| succ n ihn =>
  simp [Nat.succ_eq_add_one, h, ihn]
state_before: α : Type ?u.27138
β : Type ?u.27141
A : Type u_1
B : Type ?u.27147
F : Type u_2
inst✝² : AddMonoidWithOne B
inst✝¹ : AddMonoid A
inst✝ : AddMonoidHomClass F ℕ A
f g : F
h : ↑f 1 = ↑g 1
n : ℕ
⊢ ↑f n = ↑g n

tactic: simp_rw [Nat.zero_eq, map_zero f, map_zero g]
state_before: case zero
α : Type ?u.27138
β : Type ?u.27141
A : Type u_1
B : Type ?u.27147
F : Type u_2
inst✝² : AddMonoidWithOne B
inst✝¹ : AddMonoid A
inst✝ : AddMonoidHomClass F ℕ A
f g : F
h : ↑f 1 = ↑g 1
⊢ ↑f Nat.zero = ↑g Nat.zero

tactic: simp [Nat.succ_eq_add_one, h, ihn]
state_before: case succ
α : Type ?u.27138
β : Type ?u.27141
A : Type u_1
B : Type ?u.27147
F : Type u_2
inst✝² : AddMonoidWithOne B
inst✝¹ : AddMonoid A
inst✝ : AddMonoidHomClass F ℕ A
f g : F
h : ↑f 1 = ↑g 1
n : ℕ
ihn : ↑f n = ↑g n
⊢ ↑f (Nat.succ n) = ↑g (Nat.succ n)
Theorem: Int.modEq_iff_dvd
File: Mathlib/Data/Int/ModEq.lean

tactic: rw [ModEq, eq_comm]
state_before: m n a b c d : ℤ
⊢ a ≡ b [ZMOD n] ↔ n ∣ b - a

tactic: simp [emod_eq_emod_iff_emod_sub_eq_zero, dvd_iff_emod_eq_zero]
state_before: m n a b c d : ℤ
⊢ b % n = a % n ↔ n ∣ b - a
Theorem: Vector.continuousAt_removeNth
File: Mathlib/Topology/List.lean

tactic: rw [ContinuousAt, removeNth, tendsto_subtype_rng]
state_before: α : Type u_1
β : Type ?u.68450
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
l : List α
hl : List.length l = n + 1
⊢ ContinuousAt (removeNth i) { val := l, property := hl }

tactic: simp only [Vector.removeNth_val]
state_before: α : Type u_1
β : Type ?u.68450
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
l : List α
hl : List.length l = n + 1
⊢ Tendsto (fun x => ↑(removeNth i x)) (𝓝 { val := l, property := hl })
    (𝓝
      ↑(match { val := l, property := hl } with
        | { val := l, property := p } =>
          { val := List.removeNth l ↑i, property := (_ : List.length (List.removeNth l ↑i) = n + 1 - 1) }))

tactic: exact Tendsto.comp List.tendsto_removeNth continuousAt_subtype_val
state_before: α : Type u_1
β : Type ?u.68450
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
l : List α
hl : List.length l = n + 1
⊢ Tendsto (fun x => List.removeNth ↑x ↑i) (𝓝 { val := l, property := hl }) (𝓝 (List.removeNth l ↑i))
Theorem: Finset.min'_mem
File: Mathlib/Data/Finset/Lattice.lean

tactic: simp only [Finset.min, min', id_eq, coe_inf']
state_before: F : Type ?u.332825
α : Type u_1
β : Type ?u.332831
γ : Type ?u.332834
ι : Type ?u.332837
κ : Type ?u.332840
inst✝ : LinearOrder α
s : Finset α
H : Finset.Nonempty s
x : α
⊢ Finset.min s = ↑(min' s H)

tactic: rfl
state_before: F : Type ?u.332825
α : Type u_1
β : Type ?u.332831
γ : Type ?u.332834
ι : Type ?u.332837
κ : Type ?u.332840
inst✝ : LinearOrder α
s : Finset α
H : Finset.Nonempty s
x : α
⊢ inf s WithTop.some = inf s (WithTop.some ∘ fun x => x)