tasksource/leandojo huggingface dataset:
Theorem: MulAction.mem_fixedPoints_iff_card_orbit_eq_one
File: Mathlib/GroupTheory/GroupAction/Basic.lean

tactic: rw [Fintype.card_eq_one_iff, mem_fixedPoints]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : Monoid α
inst✝¹ : MulAction α β
a : β
inst✝ : Fintype ↑(orbit α a)
⊢ a ∈ fixedPoints α β ↔ Fintype.card ↑(orbit α a) = 1

tactic: constructor
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : Monoid α
inst✝¹ : MulAction α β
a : β
inst✝ : Fintype ↑(orbit α a)
⊢ (∀ (x : α), x • a = a) ↔ ∃ x, ∀ (y : ↑(orbit α a)), y = x

tactic: exact fun h => ⟨⟨a, mem_orbit_self _⟩, fun ⟨b, ⟨x, hx⟩⟩ => Subtype.eq <| by simp [h x, hx.symm]⟩
state_before: case mp
α : Type u
β : Type v
γ : Type w
inst✝² : Monoid α
inst✝¹ : MulAction α β
a : β
inst✝ : Fintype ↑(orbit α a)
⊢ (∀ (x : α), x • a = a) → ∃ x, ∀ (y : ↑(orbit α a)), y = x

tactic: simp [h x, hx.symm]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : Monoid α
inst✝¹ : MulAction α β
a : β
inst✝ : Fintype ↑(orbit α a)
h : ∀ (x : α), x • a = a
x✝ : ↑(orbit α a)
b : β
x : α
hx : (fun x => x • a) x = b
⊢ ↑{ val := b, property := (_ : ∃ y, (fun x => x • a) y = b) } = ↑{ val := a, property := (_ : a ∈ orbit α a) }

tactic: intro h x
state_before: case mpr
α : Type u
β : Type v
γ : Type w
inst✝² : Monoid α
inst✝¹ : MulAction α β
a : β
inst✝ : Fintype ↑(orbit α a)
⊢ (∃ x, ∀ (y : ↑(orbit α a)), y = x) → ∀ (x : α), x • a = a

tactic: rcases h with ⟨⟨z, hz⟩, hz₁⟩
state_before: case mpr
α : Type u
β : Type v
γ : Type w
inst✝² : Monoid α
inst✝¹ : MulAction α β
a : β
inst✝ : Fintype ↑(orbit α a)
h : ∃ x, ∀ (y : ↑(orbit α a)), y = x
x : α
⊢ x • a = a

tactic: calc
  x • a = z := Subtype.mk.inj (hz₁ ⟨x • a, mem_orbit _ _⟩)
  _ = a := (Subtype.mk.inj (hz₁ ⟨a, mem_orbit_self _⟩)).symm
state_before: case mpr.intro.mk
α : Type u
β : Type v
γ : Type w
inst✝² : Monoid α
inst✝¹ : MulAction α β
a : β
inst✝ : Fintype ↑(orbit α a)
x : α
z : β
hz : z ∈ orbit α a
hz₁ : ∀ (y : ↑(orbit α a)), y = { val := z, property := hz }
⊢ x • a = a
Theorem: LatticeOrderedCommGroup.m_pos_abs
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: nth_rw 2 [← pos_div_neg (|a|)]
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⁺ = abs a

tactic: rw [div_eq_mul_inv]
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⁺ = abs a⁺ / abs a⁻

tactic: 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⁺ = abs a⁺ * (abs a⁻)⁻¹

tactic: rw [mul_right_eq_self, inv_eq_one]
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⁺ * (abs a⁻)⁻¹ = abs a⁺

tactic: exact m_neg_abs a
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⁻ = 1
Theorem: CategoryTheory.NatTrans.app_sum
File: Mathlib/CategoryTheory/Preadditive/FunctorCategory.lean

tactic: simp only [← appHom_apply, map_sum]
state_before: C : Type u_2
D : Type u_4
inst✝² : Category C
inst✝¹ : Category D
inst✝ : Preadditive D
F G : C ⥤ D
ι : Type u_1
s : Finset ι
X : C
α : ι → (F ⟶ G)
⊢ (∑ i in s, α i).app X = ∑ i in s, (α i).app X
Theorem: ClosureOperator.closed_eq_range_close
File: Mathlib/Order/Closure.lean

tactic: rintro ⟨y, rfl⟩
state_before: α : Type u_1
ι : Sort ?u.5391
κ : ι → Sort ?u.5396
inst✝¹ inst✝ : PartialOrder α
c : ClosureOperator α
x : α
⊢ x ∈ Set.range ↑c.toOrderHom → x ∈ closed c

tactic: apply c.idempotent
state_before: case intro
α : Type u_1
ι : Sort ?u.5391
κ : ι → Sort ?u.5396
inst✝¹ inst✝ : PartialOrder α
c : ClosureOperator α
y : α
⊢ ↑c.toOrderHom y ∈ closed c
Theorem: Finset.eq_empty_of_sym_eq_empty
File: Mathlib/Data/Finset/Sym.lean

tactic: rw [← not_nonempty_iff_eq_empty] at h⊢
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
n : ℕ
m : Sym α n
h : Finset.sym s n = ∅
⊢ s = ∅

tactic: exact fun hs ↦ h (hs.sym _)
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
n : ℕ
m : Sym α n
h : ¬Finset.Nonempty (Finset.sym s n)
⊢ ¬Finset.Nonempty s
Theorem: Algebra.smul_leftMulMatrix_algebraMap_eq
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: rw [smul_leftMulMatrix_algebraMap, blockDiagonal_apply_eq]
state_before: R : Type u_1
S : Type u_5
T : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Ring T
inst✝⁷ : Algebra R S
inst✝⁶ : Algebra S T
inst✝⁵ : Algebra R T
inst✝⁴ : IsScalarTower R S T
m : Type u_3
n : Type u_4
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
b : Basis m R S
c : Basis n S T
x : S
i j : m
k : n
⊢ ↑(leftMulMatrix (Basis.smul b c)) (↑(algebraMap S T) x) (i, k) (j, k) = ↑(leftMulMatrix b) x i j
Theorem: MeasureTheory.fundamentalInterior_smul
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: simp_rw [fundamentalInterior, smul_set_sdiff, smul_set_Union, smul_comm g (_ : G) (_ : Set α)]
state_before: G : Type u_3
H : Type u_1
α : Type u_2
β : Type ?u.505777
E : Type ?u.505780
inst✝⁴ : Group G
inst✝³ : MulAction G α
s : Set α
x : α
inst✝² : Group H
inst✝¹ : MulAction H α
inst✝ : SMulCommClass H G α
g : H
⊢ fundamentalInterior G (g • s) = g • fundamentalInterior G s
Theorem: Finset.mulDysonEtransform_idem
File: Mathlib/Combinatorics/Additive/Etransform.lean

tactic: ext : 1 <;> dsimp
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ mulDysonEtransform e (mulDysonEtransform e x) = mulDysonEtransform e x

tactic: rw [smul_finset_inter, smul_inv_smul, inter_comm, union_eq_left_iff_subset]
state_before: case h₁
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ x.fst ∪ e • x.snd ∪ e • (x.snd ∩ e⁻¹ • x.fst) = x.fst ∪ e • x.snd

tactic: exact inter_subset_union
state_before: case h₁
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ x.fst ∩ e • x.snd ⊆ x.fst ∪ e • x.snd

tactic: rw [smul_finset_union, inv_smul_smul, union_comm, inter_eq_left_iff_subset]
state_before: case h₂
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ x.snd ∩ e⁻¹ • x.fst ∩ e⁻¹ • (x.fst ∪ e • x.snd) = x.snd ∩ e⁻¹ • x.fst

tactic: exact inter_subset_union
state_before: case h₂
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ x.snd ∩ e⁻¹ • x.fst ⊆ x.snd ∪ e⁻¹ • x.fst
Theorem: map_rootsOfUnity_eq_pow_self
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: obtain ⟨m, hm⟩ := MonoidHom.map_cyclic (restrictRootsOfUnity σ k)
state_before: M : Type ?u.1286508
N : Type ?u.1286511
G : Type ?u.1286514
R : Type u_2
S : Type ?u.1286520
F : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : CommMonoid N
inst✝³ : DivisionCommMonoid G
k l : ℕ+
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : RingHomClass F R R
σ : F
ζ : { x // x ∈ rootsOfUnity k R }
⊢ ∃ m, ↑σ ↑↑ζ = ↑↑ζ ^ m

tactic: rw [← restrictRootsOfUnity_coe_apply, hm, zpow_eq_mod_orderOf, ← Int.toNat_of_nonneg
    (m.emod_nonneg (Int.coe_nat_ne_zero.mpr (pos_iff_ne_zero.mp (orderOf_pos ζ)))),
  zpow_ofNat, rootsOfUnity.coe_pow]
state_before: case intro
M : Type ?u.1286508
N : Type ?u.1286511
G : Type ?u.1286514
R : Type u_2
S : Type ?u.1286520
F : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : CommMonoid N
inst✝³ : DivisionCommMonoid G
k l : ℕ+
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : RingHomClass F R R
σ : F
ζ : { x // x ∈ rootsOfUnity k R }
m : ℤ
hm : ∀ (g : { x // x ∈ rootsOfUnity k R }), ↑(restrictRootsOfUnity σ k) g = g ^ m
⊢ ∃ m, ↑σ ↑↑ζ = ↑↑ζ ^ m

tactic: exact ⟨(m % orderOf ζ).toNat, rfl⟩
state_before: case intro
M : Type ?u.1286508
N : Type ?u.1286511
G : Type ?u.1286514
R : Type u_2
S : Type ?u.1286520
F : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : CommMonoid N
inst✝³ : DivisionCommMonoid G
k l : ℕ+
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : RingHomClass F R R
σ : F
ζ : { x // x ∈ rootsOfUnity k R }
m : ℤ
hm : ∀ (g : { x // x ∈ rootsOfUnity k R }), ↑(restrictRootsOfUnity σ k) g = g ^ m
⊢ ∃ m_1, ↑↑ζ ^ Int.toNat (m % ↑(orderOf ζ)) = ↑↑ζ ^ m_1
Theorem: Bool.and_elim_right
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ {a b : Bool}, (a && b) = true → b = true
Theorem: Set.preimage_const_mul_Ioo_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simpa only [mul_comm] using preimage_mul_const_Ioo_of_neg a b h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : c < 0
⊢ (fun x x_1 => x * x_1) c ⁻¹' Ioo a b = Ioo (b / c) (a / c)
Theorem: Rat.divInt_eq_iff
File: Std/Data/Rat/Lemmas.lean

tactic: rcases Int.eq_nat_or_neg d₁ with ⟨_, rfl | rfl⟩ <;>
rcases Int.eq_nat_or_neg d₂ with ⟨_, rfl | rfl⟩ <;>
simp_all [divInt_neg', Int.ofNat_eq_zero, Int.neg_eq_zero,
  mkRat_eq_iff, Int.neg_mul, Int.mul_neg, Int.eq_neg_comm, eq_comm]
state_before: d₁ d₂ n₁ n₂ : Int
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
⊢ n₁ /. d₁ = n₂ /. d₂ ↔ n₁ * d₂ = n₂ * d₁
Theorem: Ring.inverse_mul_cancel_right
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rw [mul_assoc, inverse_mul_cancel x h, mul_one]
state_before: α : Type ?u.7284
M₀ : Type u_1
G₀ : Type ?u.7290
M₀' : Type ?u.7293
G₀' : Type ?u.7296
F : Type ?u.7299
F' : Type ?u.7302
inst✝ : MonoidWithZero M₀
x y : M₀
h : IsUnit x
⊢ y * inverse x * x = y
Theorem: pi_Ico_mem_nhds
File: Mathlib/Topology/Order/Basic.lean

tactic: refine' mem_of_superset (set_pi_mem_nhds Set.finite_univ fun i _ => _) (pi_univ_Ico_subset a b)
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : TopologicalSpace α
inst✝⁶ : LinearOrder α
inst✝⁵ : OrderTopology α
ι : Type u_2
π : ι → Type u_1
inst✝⁴ : Finite ι
inst✝³ : (i : ι) → LinearOrder (π i)
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : ∀ (i : ι), OrderTopology (π i)
a b x : (i : ι) → π i
a' b' x' : ι → α
inst✝ : Nonempty ι
ha : ∀ (i : ι), a i < x i
hb : ∀ (i : ι), x i < b i
⊢ Ico a b ∈ 𝓝 x

tactic: exact Ico_mem_nhds (ha i) (hb i)
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : TopologicalSpace α
inst✝⁶ : LinearOrder α
inst✝⁵ : OrderTopology α
ι : Type u_2
π : ι → Type u_1
inst✝⁴ : Finite ι
inst✝³ : (i : ι) → LinearOrder (π i)
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : ∀ (i : ι), OrderTopology (π i)
a b x : (i : ι) → π i
a' b' x' : ι → α
inst✝ : Nonempty ι
ha : ∀ (i : ι), a i < x i
hb : ∀ (i : ι), x i < b i
i : ι
x✝ : i ∈ univ
⊢ Ico (a i) (b i) ∈ 𝓝 (x i)
Theorem: MvPolynomial.supportedEquivMvPolynomial_symm_C
File: Mathlib/Data/MvPolynomial/Supported.lean

tactic: ext1
state_before: σ : Type u_1
τ : Type ?u.7855
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : Set σ
x : R
⊢ ↑(AlgEquiv.symm (supportedEquivMvPolynomial s)) (↑C x) = ↑(algebraMap R { x // x ∈ supported R s }) x

tactic: simp [supportedEquivMvPolynomial, MvPolynomial.algebraMap_eq]
state_before: case a
σ : Type u_1
τ : Type ?u.7855
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : Set σ
x : R
⊢ ↑(↑(AlgEquiv.symm (supportedEquivMvPolynomial s)) (↑C x)) = ↑(↑(algebraMap R { x // x ∈ supported R s }) x)
Theorem: Cardinal.nat_add_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [add_comm, aleph0_add_nat]
state_before: α β : Type u
n : ℕ
⊢ ↑n + ℵ₀ = ℵ₀
Theorem: Submonoid.sup_eq_closure
File: Mathlib/GroupTheory/Submonoid/Pointwise.lean

tactic: rw [closure_eq, closure_eq]
state_before: α : Type ?u.9470
G : Type ?u.9473
M : Type u_1
R : Type ?u.9479
A : Type ?u.9482
inst✝¹ : Monoid M
inst✝ : AddMonoid A
s t u : Set M
H K : Submonoid M
⊢ closure ↑H ⊔ closure ↑K ≤ H ⊔ K
Theorem: Polynomial.degree_gcd_le_left
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: have := natDegree_le_iff_degree_le.mp (natDegree_le_of_dvd (gcd_dvd_left p q) hp)
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp : p ≠ 0
q : R[X]
⊢ degree (gcd p q) ≤ degree p

tactic: rwa [degree_eq_natDegree hp]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp : p ≠ 0
q : R[X]
this : degree (gcd p q) ≤ ↑(natDegree p)
⊢ degree (gcd p q) ≤ degree p
Theorem: Valuation.Integers.le_of_dvd
File: Mathlib/RingTheory/Valuation/Integers.lean

tactic: let ⟨z, hz⟩ := h
state_before: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : Integers v O
x y : O
h : x ∣ y
⊢ ↑v (↑(algebraMap O R) y) ≤ ↑v (↑(algebraMap O R) x)

tactic: rw [← mul_one (v (algebraMap O R x)), hz, RingHom.map_mul, v.map_mul]
state_before: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : Integers v O
x y : O
h : x ∣ y
z : O
hz : y = x * z
⊢ ↑v (↑(algebraMap O R) y) ≤ ↑v (↑(algebraMap O R) x)

tactic: exact mul_le_mul_left' (hv.2 z) _
state_before: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : Integers v O
x y : O
h : x ∣ y
z : O
hz : y = x * z
⊢ ↑v (↑(algebraMap O R) x) * ↑v (↑(algebraMap O R) z) ≤ ↑v (↑(algebraMap O R) x) * 1
Theorem: Polynomial.coeff_mul_X_sub_C
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simp [mul_sub]
state_before: R : Type u
S : Type v
a✝ b c d : R
n m : ℕ
inst✝ : Ring R
p : R[X]
r : R
a : ℕ
⊢ coeff (p * (X - ↑C r)) (a + 1) = coeff p a - coeff p (a + 1) * r
Theorem: CategoryTheory.Limits.WidePullback.hom_eq_lift
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

tactic: aesop_cat
state_before: J : Type w
C : Type u
inst✝² : Category C
D : Type ?u.242573
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
⊢ ∀ (j : J), (fun j => g ≫ π arrows j) j ≫ arrows j = g ≫ base arrows

tactic: apply eq_lift_of_comp_eq
state_before: J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
⊢ g = lift (g ≫ base arrows) (fun j => g ≫ π arrows j) (_ : ∀ (j : J), (g ≫ π arrows j) ≫ arrows j = g ≫ base arrows)

tactic: aesop_cat
state_before: case a
J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
⊢ ∀ (j : J), g ≫ π arrows j = g ≫ π arrows j

case a
J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
⊢ g ≫ base arrows = g ≫ base arrows

tactic: rfl
state_before: case a
J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → objs j ⟶ B
inst✝ : HasWidePullback B objs arrows
X : D
f : X ⟶ B
fs : (j : J) → X ⟶ objs j
w : ∀ (j : J), fs j ≫ arrows j = f
g : X ⟶ widePullback B (fun j => objs j) arrows
⊢ g ≫ base arrows = g ≫ base arrows
Theorem: PadicInt.isUnit_iff
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: rcases isUnit_iff_dvd_one.1 h with ⟨w, eq⟩
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
h : IsUnit z
⊢ ‖z‖ = 1

tactic: refine' le_antisymm (norm_le_one _) _
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
h : IsUnit z
w : ℤ_[p]
eq : 1 = z * w
⊢ ‖z‖ = 1

tactic: have := mul_le_mul_of_nonneg_left (norm_le_one w) (norm_nonneg z)
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
h : IsUnit z
w : ℤ_[p]
eq : 1 = z * w
⊢ 1 ≤ ‖z‖

tactic: rwa [mul_one, ← norm_mul, ← eq, norm_one] at this
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ_[p]
h : IsUnit z
w : ℤ_[p]
eq : 1 = z * w
this : ‖z‖ * ‖w‖ ≤ ‖z‖ * 1
⊢ 1 ≤ ‖z‖
Theorem: Ultrafilter.disjoint_iff_not_le
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: rw [← inf_neBot_iff, neBot_iff, Ne.def, not_not, disjoint_iff]
state_before: α : Type u
β : Type v
γ : Type ?u.6498
f✝ g✝ : Ultrafilter α
s t : Set α
p q : α → Prop
f : Ultrafilter α
g : Filter α
⊢ Disjoint (↑f) g ↔ ¬↑f ≤ g
Theorem: Submonoid.closure_induction_left
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: rw [closure_eq_mrange] at h
state_before: M : Type u_1
A : Type ?u.83795
B : Type ?u.83798
inst✝ : Monoid M
s : Set M
p : M → Prop
x : M
h : x ∈ closure s
H1 : p 1
Hmul : ∀ (x : M), x ∈ s → ∀ (y : M), p y → p (x * y)
⊢ p x

tactic: obtain ⟨l, rfl⟩ := h
state_before: M : Type u_1
A : Type ?u.83795
B : Type ?u.83798
inst✝ : Monoid M
s : Set M
p : M → Prop
x : M
h : x ∈ mrange (↑FreeMonoid.lift Subtype.val)
H1 : p 1
Hmul : ∀ (x : M), x ∈ s → ∀ (y : M), p y → p (x * y)
⊢ p x

tactic: induction' l using FreeMonoid.recOn with x y ih
state_before: case intro
M : Type u_1
A : Type ?u.83795
B : Type ?u.83798
inst✝ : Monoid M
s : Set M
p : M → Prop
H1 : p 1
Hmul : ∀ (x : M), x ∈ s → ∀ (y : M), p y → p (x * y)
l : FreeMonoid { x // x ∈ s }
⊢ p (↑(↑FreeMonoid.lift Subtype.val) l)

tactic: exact H1
state_before: case intro.h0
M : Type u_1
A : Type ?u.83795
B : Type ?u.83798
inst✝ : Monoid M
s : Set M
p : M → Prop
H1 : p 1
Hmul : ∀ (x : M), x ∈ s → ∀ (y : M), p y → p (x * y)
⊢ p (↑(↑FreeMonoid.lift Subtype.val) 1)

tactic: simpa only [map_mul, FreeMonoid.lift_eval_of] using Hmul _ x.prop _ ih
state_before: case intro.ih
M : Type u_1
A : Type ?u.83795
B : Type ?u.83798
inst✝ : Monoid M
s : Set M
p : M → Prop
H1 : p 1
Hmul : ∀ (x : M), x ∈ s → ∀ (y : M), p y → p (x * y)
x : { x // x ∈ s }
y : FreeMonoid { x // x ∈ s }
ih : p (↑(↑FreeMonoid.lift Subtype.val) y)
⊢ p (↑(↑FreeMonoid.lift Subtype.val) (FreeMonoid.of x * y))
Theorem: Continuous.congr
File: Mathlib/Topology/Basic.lean

tactic: convert h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.162528
δ : Type ?u.162531
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f g : α → β
h : Continuous f
h' : ∀ (x : α), f x = g x
⊢ Continuous g

tactic: ext
state_before: case h.e'_5
α : Type u_1
β : Type u_2
γ : Type ?u.162528
δ : Type ?u.162531
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f g : α → β
h : Continuous f
h' : ∀ (x : α), f x = g x
⊢ g = f

tactic: rw [h']
state_before: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type ?u.162528
δ : Type ?u.162531
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f g : α → β
h : Continuous f
h' : ∀ (x : α), f x = g x
x✝ : α
⊢ g x✝ = f x✝
Theorem: Set.ssubset_singleton_iff
File: Mathlib/Data/Set/Basic.lean

tactic: rw [ssubset_iff_subset_ne, subset_singleton_iff_eq, or_and_right, and_not_self_iff, or_false_iff,
  and_iff_left_iff_imp]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
x : α
⊢ s ⊂ {x} ↔ s = ∅

tactic: exact fun h => h ▸ (singleton_ne_empty _).symm
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
x : α
⊢ s = ∅ → s ≠ {x}
Theorem: EuclideanDomain.lcm_zero_left
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rw [lcm, zero_mul, zero_div]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x : R
⊢ lcm 0 x = 0
Theorem: Matrix.conjTranspose_zsmul
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp
state_before: l : Type ?u.986278
m : Type u_1
n : Type u_2
o : Type ?u.986287
m' : o → Type ?u.986292
n' : o → Type ?u.986297
R : Type ?u.986300
S : Type ?u.986303
α : Type v
β : Type w
γ : Type ?u.986310
inst✝¹ : AddGroup α
inst✝ : StarAddMonoid α
c : ℤ
M : Matrix m n α
⊢ ∀ (i : n) (j : m), (c • M)ᴴ i j = (c • Mᴴ) i j
Theorem: SimpleGraph.sum_incMatrix_apply
File: Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean

tactic: simp [incMatrix_apply', sum_boole, Set.filter_mem_univ_eq_toFinset]
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝³ : Fintype α
inst✝² : NonAssocSemiring R
a b : α
e : Sym2 α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
⊢ ∑ e : Sym2 α, incMatrix R G a e = ↑(degree G a)
Theorem: BumpCovering.exists_isSubordinate_of_prop
File: Mathlib/Topology/PartitionOfUnity.lean

tactic: rcases precise_refinement_set hs _ ho hU with ⟨V, hVo, hsV, hVf, hVU⟩
state_before: ι : Type u
X : Type v
inst✝² : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
inst✝¹ : NormalSpace X
inst✝ : ParacompactSpace X
p : (X → ℝ) → Prop
h01 :
  ∀ (s t : Set X),
    IsClosed s → IsClosed t → Disjoint s t → ∃ f, p ↑f ∧ EqOn (↑f) 0 s ∧ EqOn (↑f) 1 t ∧ ∀ (x : X), ↑f x ∈ Icc 0 1
hs : IsClosed s
U : ι → Set X
ho : ∀ (i : ι), IsOpen (U i)
hU : s ⊆ ⋃ (i : ι), U i
⊢ ∃ f, (∀ (i : ι), p ↑(toFun s f i)) ∧ IsSubordinate f U

tactic: rcases exists_isSubordinate_of_locallyFinite_of_prop p h01 hs V hVo hVf hsV with ⟨f, hfp, hf⟩
state_before: case intro.intro.intro.intro
ι : Type u
X : Type v
inst✝² : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
inst✝¹ : NormalSpace X
inst✝ : ParacompactSpace X
p : (X → ℝ) → Prop
h01 :
  ∀ (s t : Set X),
    IsClosed s → IsClosed t → Disjoint s t → ∃ f, p ↑f ∧ EqOn (↑f) 0 s ∧ EqOn (↑f) 1 t ∧ ∀ (x : X), ↑f x ∈ Icc 0 1
hs : IsClosed s
U : ι → Set X
ho : ∀ (i : ι), IsOpen (U i)
hU : s ⊆ ⋃ (i : ι), U i
V : ι → Set X
hVo : ∀ (i : ι), IsOpen (V i)
hsV : s ⊆ ⋃ (i : ι), V i
hVf : LocallyFinite V
hVU : ∀ (i : ι), V i ⊆ U i
⊢ ∃ f, (∀ (i : ι), p ↑(toFun s f i)) ∧ IsSubordinate f U

tactic: exact ⟨f, hfp, hf.mono hVU⟩
state_before: case intro.intro.intro.intro.intro.intro
ι : Type u
X : Type v
inst✝² : TopologicalSpace X
s : Set X
f✝ : BumpCovering ι X s
inst✝¹ : NormalSpace X
inst✝ : ParacompactSpace X
p : (X → ℝ) → Prop
h01 :
  ∀ (s t : Set X),
    IsClosed s → IsClosed t → Disjoint s t → ∃ f, p ↑f ∧ EqOn (↑f) 0 s ∧ EqOn (↑f) 1 t ∧ ∀ (x : X), ↑f x ∈ Icc 0 1
hs : IsClosed s
U : ι → Set X
ho : ∀ (i : ι), IsOpen (U i)
hU : s ⊆ ⋃ (i : ι), U i
V : ι → Set X
hVo : ∀ (i : ι), IsOpen (V i)
hsV : s ⊆ ⋃ (i : ι), V i
hVf : LocallyFinite V
hVU : ∀ (i : ι), V i ⊆ U i
f : BumpCovering ι X s
hfp : ∀ (i : ι), p ↑(toFun s f i)
hf : IsSubordinate f V
⊢ ∃ f, (∀ (i : ι), p ↑(toFun s f i)) ∧ IsSubordinate f U
Theorem: SNum.bit_one
File: Mathlib/Data/Num/Bitwise.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ (b::zero (decide ¬b = true)) = nz (msb b)
Theorem: set_integral_withDensity_eq_set_integral_smul
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [restrict_withDensity hs, integral_withDensity_eq_integral_smul f_meas]
state_before: α : Type u_1
β : Type ?u.4658033
E : Type u_2
F : Type ?u.4658039
inst✝⁹ : MeasurableSpace α
ι : Type ?u.4658045
inst✝⁸ : NormedAddCommGroup E
μ : MeasureTheory.Measure α
𝕜 : Type ?u.4772853
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝³ : CompleteSpace E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace F
inst✝ : NormedSpace ℝ F
f : α → ℝ≥0
f_meas : Measurable f
g : α → E
s : Set α
hs : MeasurableSet s
⊢ (∫ (a : α) in s, g a ∂Measure.withDensity μ fun x => ↑(f x)) = ∫ (a : α) in s, f a • g a ∂μ
Theorem: Submonoid.mrange_inl
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: simpa only [mrange_eq_map] using map_inl ⊤
state_before: M : Type u_1
N : Type u_2
P : Type ?u.149993
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.150014
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ mrange (inl M N) = prod ⊤ ⊥